niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1 | /* |
andrew@webrtc.org | 293d22b | 2012-01-30 22:04:26 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 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 | */ |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 10 | #include "modules/audio_processing/include/audio_processing.h" |
| 11 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 12 | #include <math.h> |
ajm@google.com | 59e4140 | 2011-07-28 17:34:04 | [diff] [blame] | 13 | #include <stdio.h> |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 14 | |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 15 | #include <algorithm> |
Oleh Prypin | 708eccc | 2019-03-27 08:38:52 | [diff] [blame] | 16 | #include <cmath> |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 17 | #include <limits> |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 18 | #include <memory> |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 19 | #include <numeric> |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 20 | #include <queue> |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 21 | #include <string> |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 22 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 23 | #include "absl/flags/flag.h" |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 24 | #include "absl/strings/string_view.h" |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 25 | #include "api/audio/echo_detector_creator.h" |
Niels Möller | 105711e | 2022-06-14 13:48:26 | [diff] [blame] | 26 | #include "api/make_ref_counted.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 27 | #include "common_audio/include/audio_util.h" |
| 28 | #include "common_audio/resampler/include/push_resampler.h" |
| 29 | #include "common_audio/resampler/push_sinc_resampler.h" |
| 30 | #include "common_audio/signal_processing/include/signal_processing_library.h" |
| 31 | #include "modules/audio_processing/aec_dump/aec_dump_factory.h" |
| 32 | #include "modules/audio_processing/audio_processing_impl.h" |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 33 | #include "modules/audio_processing/include/mock_audio_processing.h" |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 34 | #include "modules/audio_processing/test/audio_processing_builder_for_testing.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 35 | #include "modules/audio_processing/test/protobuf_utils.h" |
| 36 | #include "modules/audio_processing/test/test_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 37 | #include "rtc_base/arraysize.h" |
| 38 | #include "rtc_base/checks.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 39 | #include "rtc_base/fake_clock.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 40 | #include "rtc_base/gtest_prod_util.h" |
Mirko Bonadei | 5b86f0a | 2017-11-29 14:20:26 | [diff] [blame] | 41 | #include "rtc_base/numerics/safe_conversions.h" |
Karl Wiberg | e40468b | 2017-11-22 09:42:26 | [diff] [blame] | 42 | #include "rtc_base/numerics/safe_minmax.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 43 | #include "rtc_base/protobuf_utils.h" |
Jonas Olsson | 366a50c | 2018-09-06 11:41:30 | [diff] [blame] | 44 | #include "rtc_base/strings/string_builder.h" |
Alessio Bazzica | c054e78 | 2018-04-16 10:10:09 | [diff] [blame] | 45 | #include "rtc_base/swap_queue.h" |
Niels Möller | a12c42a | 2018-07-25 14:05:48 | [diff] [blame] | 46 | #include "rtc_base/system/arch.h" |
Danil Chapovalov | 07122bc | 2019-03-26 13:37:01 | [diff] [blame] | 47 | #include "rtc_base/task_queue_for_test.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 48 | #include "rtc_base/thread.h" |
Per Åhgren | a43178c | 2020-09-25 10:02:32 | [diff] [blame] | 49 | #include "system_wrappers/include/cpu_features_wrapper.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 50 | #include "test/gtest.h" |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 51 | #include "test/testsupport/file_utils.h" |
kwiberg | 77eab70 | 2016-09-29 00:42:01 | [diff] [blame] | 52 | |
leozwang@webrtc.org | a373634 | 2012-03-16 21:36:00 | [diff] [blame] | 53 | #ifdef WEBRTC_ANDROID_PLATFORM_BUILD |
Björn Terelius | efeeba0 | 2023-10-31 14:44:50 | [diff] [blame] | 54 | #include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h" |
leozwang@webrtc.org | 534e495 | 2012-10-22 21:21:52 | [diff] [blame] | 55 | #include "external/webrtc/webrtc/modules/audio_processing/test/unittest.pb.h" |
leozwang@webrtc.org | a373634 | 2012-03-16 21:36:00 | [diff] [blame] | 56 | #else |
Björn Terelius | efeeba0 | 2023-10-31 14:44:50 | [diff] [blame] | 57 | #include "modules/audio_processing/debug.pb.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 58 | #include "modules/audio_processing/test/unittest.pb.h" |
leozwang@webrtc.org | a373634 | 2012-03-16 21:36:00 | [diff] [blame] | 59 | #endif |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 60 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 61 | ABSL_FLAG(bool, |
| 62 | write_apm_ref_data, |
| 63 | false, |
| 64 | "Write ApmTest.Process results to file, instead of comparing results " |
| 65 | "to the existing reference data file."); |
| 66 | |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 67 | namespace webrtc { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 68 | namespace { |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 69 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 70 | // All sample rates used by APM internally during processing. Other input / |
| 71 | // output rates are resampled to / from one of these. |
| 72 | const int kProcessSampleRates[] = {16000, 32000, 48000}; |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 73 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 74 | enum StreamDirection { kForward = 0, kReverse }; |
| 75 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 76 | void ConvertToFloat(const int16_t* int_data, ChannelBuffer<float>* cb) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 77 | ChannelBuffer<int16_t> cb_int(cb->num_frames(), cb->num_channels()); |
| 78 | Deinterleave(int_data, cb->num_frames(), cb->num_channels(), |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 79 | cb_int.channels()); |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 80 | for (size_t i = 0; i < cb->num_channels(); ++i) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 81 | S16ToFloat(cb_int.channels()[i], cb->num_frames(), cb->channels()[i]); |
aluebs@webrtc.org | d35a5c3 | 2015-02-10 22:52:15 | [diff] [blame] | 82 | } |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 83 | } |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 84 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 85 | void ConvertToFloat(const Int16FrameData& frame, ChannelBuffer<float>* cb) { |
| 86 | ConvertToFloat(frame.data.data(), cb); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 87 | } |
| 88 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 89 | void MixStereoToMono(const float* stereo, |
| 90 | float* mono, |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 91 | size_t samples_per_channel) { |
| 92 | for (size_t i = 0; i < samples_per_channel; ++i) |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 93 | mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) / 2; |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 94 | } |
| 95 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 96 | void MixStereoToMono(const int16_t* stereo, |
| 97 | int16_t* mono, |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 98 | size_t samples_per_channel) { |
| 99 | for (size_t i = 0; i < samples_per_channel; ++i) |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 100 | mono[i] = (stereo[i * 2] + stereo[i * 2 + 1]) >> 1; |
| 101 | } |
| 102 | |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 103 | void CopyLeftToRightChannel(int16_t* stereo, size_t samples_per_channel) { |
| 104 | for (size_t i = 0; i < samples_per_channel; i++) { |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 105 | stereo[i * 2 + 1] = stereo[i * 2]; |
| 106 | } |
| 107 | } |
| 108 | |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 109 | void VerifyChannelsAreEqual(const int16_t* stereo, size_t samples_per_channel) { |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 110 | for (size_t i = 0; i < samples_per_channel; i++) { |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 111 | EXPECT_EQ(stereo[i * 2 + 1], stereo[i * 2]); |
| 112 | } |
| 113 | } |
| 114 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 115 | void SetFrameTo(Int16FrameData* frame, int16_t value) { |
| 116 | for (size_t i = 0; i < frame->samples_per_channel * frame->num_channels; |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 117 | ++i) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 118 | frame->data[i] = value; |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 119 | } |
| 120 | } |
| 121 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 122 | void SetFrameTo(Int16FrameData* frame, int16_t left, int16_t right) { |
| 123 | ASSERT_EQ(2u, frame->num_channels); |
| 124 | for (size_t i = 0; i < frame->samples_per_channel * 2; i += 2) { |
| 125 | frame->data[i] = left; |
| 126 | frame->data[i + 1] = right; |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 127 | } |
| 128 | } |
| 129 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 130 | void ScaleFrame(Int16FrameData* frame, float scale) { |
| 131 | for (size_t i = 0; i < frame->samples_per_channel * frame->num_channels; |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 132 | ++i) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 133 | frame->data[i] = FloatS16ToS16(frame->data[i] * scale); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 134 | } |
| 135 | } |
| 136 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 137 | bool FrameDataAreEqual(const Int16FrameData& frame1, |
| 138 | const Int16FrameData& frame2) { |
| 139 | if (frame1.samples_per_channel != frame2.samples_per_channel) { |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 140 | return false; |
| 141 | } |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 142 | if (frame1.num_channels != frame2.num_channels) { |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 143 | return false; |
| 144 | } |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 145 | if (memcmp( |
| 146 | frame1.data.data(), frame2.data.data(), |
| 147 | frame1.samples_per_channel * frame1.num_channels * sizeof(int16_t))) { |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 148 | return false; |
| 149 | } |
| 150 | return true; |
| 151 | } |
| 152 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 153 | rtc::ArrayView<int16_t> GetMutableFrameData(Int16FrameData* frame) { |
| 154 | int16_t* ptr = frame->data.data(); |
| 155 | const size_t len = frame->samples_per_channel * frame->num_channels; |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 156 | return rtc::ArrayView<int16_t>(ptr, len); |
| 157 | } |
| 158 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 159 | rtc::ArrayView<const int16_t> GetFrameData(const Int16FrameData& frame) { |
| 160 | const int16_t* ptr = frame.data.data(); |
| 161 | const size_t len = frame.samples_per_channel * frame.num_channels; |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 162 | return rtc::ArrayView<const int16_t>(ptr, len); |
| 163 | } |
| 164 | |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 165 | void EnableAllAPComponents(AudioProcessing* ap) { |
Sam Zackrisson | b3b47ad | 2018-08-17 14:26:14 | [diff] [blame] | 166 | AudioProcessing::Config apm_config = ap->GetConfig(); |
| 167 | apm_config.echo_canceller.enabled = true; |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 168 | #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE) |
Sam Zackrisson | b3b47ad | 2018-08-17 14:26:14 | [diff] [blame] | 169 | apm_config.echo_canceller.mobile_mode = true; |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 170 | |
| 171 | apm_config.gain_controller1.enabled = true; |
| 172 | apm_config.gain_controller1.mode = |
| 173 | AudioProcessing::Config::GainController1::kAdaptiveDigital; |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 174 | #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
Sam Zackrisson | b3b47ad | 2018-08-17 14:26:14 | [diff] [blame] | 175 | apm_config.echo_canceller.mobile_mode = false; |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 176 | |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 177 | apm_config.gain_controller1.enabled = true; |
| 178 | apm_config.gain_controller1.mode = |
| 179 | AudioProcessing::Config::GainController1::kAdaptiveAnalog; |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 180 | #endif |
Sam Zackrisson | 2a959d9 | 2018-07-23 14:48:07 | [diff] [blame] | 181 | |
saza | 0bad15f | 2019-10-16 09:46:11 | [diff] [blame] | 182 | apm_config.noise_suppression.enabled = true; |
| 183 | |
peah | 8271d04 | 2016-11-22 15:24:52 | [diff] [blame] | 184 | apm_config.high_pass_filter.enabled = true; |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 185 | apm_config.pipeline.maximum_internal_processing_rate = 48000; |
peah | 8271d04 | 2016-11-22 15:24:52 | [diff] [blame] | 186 | ap->ApplyConfig(apm_config); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 187 | } |
| 188 | |
bjornv@webrtc.org | 8dd60cc | 2014-09-11 08:36:35 | [diff] [blame] | 189 | // These functions are only used by ApmTest.Process. |
andrew@webrtc.org | d7696c4 | 2013-12-03 23:39:16 | [diff] [blame] | 190 | template <class T> |
| 191 | T AbsValue(T a) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 192 | return a > 0 ? a : -a; |
andrew@webrtc.org | d7696c4 | 2013-12-03 23:39:16 | [diff] [blame] | 193 | } |
| 194 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 195 | int16_t MaxAudioFrame(const Int16FrameData& frame) { |
| 196 | const size_t length = frame.samples_per_channel * frame.num_channels; |
| 197 | int16_t max_data = AbsValue(frame.data[0]); |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 198 | for (size_t i = 1; i < length; i++) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 199 | max_data = std::max(max_data, AbsValue(frame.data[i])); |
andrew@webrtc.org | d7696c4 | 2013-12-03 23:39:16 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | return max_data; |
| 203 | } |
| 204 | |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 205 | void OpenFileAndWriteMessage(absl::string_view filename, |
mbonadei | 7c2c843 | 2017-04-07 07:59:12 | [diff] [blame] | 206 | const MessageLite& msg) { |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 207 | FILE* file = fopen(std::string(filename).c_str(), "wb"); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 208 | ASSERT_TRUE(file != NULL); |
| 209 | |
Mirko Bonadei | 5b86f0a | 2017-11-29 14:20:26 | [diff] [blame] | 210 | int32_t size = rtc::checked_cast<int32_t>(msg.ByteSizeLong()); |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 211 | ASSERT_GT(size, 0); |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 212 | std::unique_ptr<uint8_t[]> array(new uint8_t[size]); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 213 | ASSERT_TRUE(msg.SerializeToArray(array.get(), size)); |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 214 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 215 | ASSERT_EQ(1u, fwrite(&size, sizeof(size), 1, file)); |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 216 | ASSERT_EQ(static_cast<size_t>(size), |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 217 | fwrite(array.get(), sizeof(array[0]), size, file)); |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 218 | fclose(file); |
| 219 | } |
| 220 | |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 221 | std::string ResourceFilePath(absl::string_view name, int sample_rate_hz) { |
Jonas Olsson | 366a50c | 2018-09-06 11:41:30 | [diff] [blame] | 222 | rtc::StringBuilder ss; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 223 | // Resource files are all stereo. |
| 224 | ss << name << sample_rate_hz / 1000 << "_stereo"; |
| 225 | return test::ResourcePath(ss.str(), "pcm"); |
| 226 | } |
| 227 | |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 228 | // Temporary filenames unique to this process. Used to be able to run these |
| 229 | // tests in parallel as each process needs to be running in isolation they can't |
| 230 | // have competing filenames. |
| 231 | std::map<std::string, std::string> temp_filenames; |
| 232 | |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 233 | std::string OutputFilePath(absl::string_view name, |
andrew@webrtc.org | f26c9e8 | 2014-04-24 03:46:46 | [diff] [blame] | 234 | int input_rate, |
| 235 | int output_rate, |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 236 | int reverse_input_rate, |
| 237 | int reverse_output_rate, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 238 | size_t num_input_channels, |
| 239 | size_t num_output_channels, |
| 240 | size_t num_reverse_input_channels, |
| 241 | size_t num_reverse_output_channels, |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 242 | StreamDirection file_direction) { |
Jonas Olsson | 366a50c | 2018-09-06 11:41:30 | [diff] [blame] | 243 | rtc::StringBuilder ss; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 244 | ss << name << "_i" << num_input_channels << "_" << input_rate / 1000 << "_ir" |
| 245 | << num_reverse_input_channels << "_" << reverse_input_rate / 1000 << "_"; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 246 | if (num_output_channels == 1) { |
| 247 | ss << "mono"; |
| 248 | } else if (num_output_channels == 2) { |
| 249 | ss << "stereo"; |
| 250 | } else { |
Artem Titov | d325196 | 2021-11-15 15:57:07 | [diff] [blame] | 251 | RTC_DCHECK_NOTREACHED(); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 252 | } |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 253 | ss << output_rate / 1000; |
| 254 | if (num_reverse_output_channels == 1) { |
| 255 | ss << "_rmono"; |
| 256 | } else if (num_reverse_output_channels == 2) { |
| 257 | ss << "_rstereo"; |
| 258 | } else { |
Artem Titov | d325196 | 2021-11-15 15:57:07 | [diff] [blame] | 259 | RTC_DCHECK_NOTREACHED(); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 260 | } |
| 261 | ss << reverse_output_rate / 1000; |
| 262 | ss << "_d" << file_direction << "_pcm"; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 263 | |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 264 | std::string filename = ss.str(); |
pbos | bb36fdf | 2015-07-09 14:48:14 | [diff] [blame] | 265 | if (temp_filenames[filename].empty()) |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 266 | temp_filenames[filename] = test::TempFilename(test::OutputPath(), filename); |
| 267 | return temp_filenames[filename]; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 268 | } |
| 269 | |
pbos@webrtc.org | 200ac00 | 2015-02-03 14:14:01 | [diff] [blame] | 270 | void ClearTempFiles() { |
| 271 | for (auto& kv : temp_filenames) |
| 272 | remove(kv.second.c_str()); |
| 273 | } |
| 274 | |
Gustaf Ullberg | 8ffeeb2 | 2017-10-11 09:42:38 | [diff] [blame] | 275 | // Only remove "out" files. Keep "ref" files. |
| 276 | void ClearTempOutFiles() { |
| 277 | for (auto it = temp_filenames.begin(); it != temp_filenames.end();) { |
| 278 | const std::string& filename = it->first; |
| 279 | if (filename.substr(0, 3).compare("out") == 0) { |
| 280 | remove(it->second.c_str()); |
| 281 | temp_filenames.erase(it++); |
| 282 | } else { |
| 283 | it++; |
| 284 | } |
| 285 | } |
| 286 | } |
| 287 | |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 288 | void OpenFileAndReadMessage(absl::string_view filename, MessageLite* msg) { |
| 289 | FILE* file = fopen(std::string(filename).c_str(), "rb"); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 290 | ASSERT_TRUE(file != NULL); |
| 291 | ReadMessageFromFile(file, msg); |
andrew@webrtc.org | 8186534 | 2012-10-27 00:28:27 | [diff] [blame] | 292 | fclose(file); |
| 293 | } |
| 294 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 295 | // Reads a 10 ms chunk (actually AudioProcessing::GetFrameSize() samples per |
| 296 | // channel) of int16 interleaved audio from the given (assumed stereo) file, |
| 297 | // converts to deinterleaved float (optionally downmixing) and returns the |
| 298 | // result in `cb`. Returns false if the file ended (or on error) and true |
| 299 | // otherwise. |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 300 | // |
Artem Titov | 0b48930 | 2021-07-28 18:50:03 | [diff] [blame] | 301 | // `int_data` and `float_data` are just temporary space that must be |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 302 | // sufficiently large to hold the 10 ms chunk. |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 303 | bool ReadChunk(FILE* file, |
| 304 | int16_t* int_data, |
| 305 | float* float_data, |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 306 | ChannelBuffer<float>* cb) { |
| 307 | // The files always contain stereo audio. |
aluebs@webrtc.org | d35a5c3 | 2015-02-10 22:52:15 | [diff] [blame] | 308 | size_t frame_size = cb->num_frames() * 2; |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 309 | size_t read_count = fread(int_data, sizeof(int16_t), frame_size, file); |
| 310 | if (read_count != frame_size) { |
| 311 | // Check that the file really ended. |
kwiberg | 9e2be5f | 2016-09-14 12:23:22 | [diff] [blame] | 312 | RTC_DCHECK(feof(file)); |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 313 | return false; // This is expected. |
| 314 | } |
| 315 | |
| 316 | S16ToFloat(int_data, frame_size, float_data); |
| 317 | if (cb->num_channels() == 1) { |
aluebs@webrtc.org | d35a5c3 | 2015-02-10 22:52:15 | [diff] [blame] | 318 | MixStereoToMono(float_data, cb->channels()[0], cb->num_frames()); |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 319 | } else { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 320 | Deinterleave(float_data, cb->num_frames(), 2, cb->channels()); |
aluebs@webrtc.org | d82f55d | 2015-01-15 18:07:21 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | return true; |
| 324 | } |
| 325 | |
Per Åhgren | a43178c | 2020-09-25 10:02:32 | [diff] [blame] | 326 | // Returns the reference file name that matches the current CPU |
| 327 | // architecture/optimizations. |
| 328 | std::string GetReferenceFilename() { |
| 329 | #if defined(WEBRTC_AUDIOPROC_FIXED_PROFILE) |
| 330 | return test::ResourcePath("audio_processing/output_data_fixed", "pb"); |
| 331 | #elif defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
| 332 | if (GetCPUInfo(kAVX2) != 0) { |
| 333 | return test::ResourcePath("audio_processing/output_data_float_avx2", "pb"); |
| 334 | } |
| 335 | return test::ResourcePath("audio_processing/output_data_float", "pb"); |
| 336 | #endif |
| 337 | } |
| 338 | |
Alessio Bazzica | 85a126e | 2022-08-11 13:48:54 | [diff] [blame] | 339 | // Flag that can temporarily be enabled for local debugging to inspect |
| 340 | // `ApmTest.VerifyDebugDump(Int|Float)` failures. Do not upload code changes |
| 341 | // with this flag set to true. |
| 342 | constexpr bool kDumpWhenExpectMessageEqFails = false; |
| 343 | |
| 344 | // Checks the debug constants values used in this file so that no code change is |
| 345 | // submitted with values temporarily used for local debugging. |
| 346 | TEST(ApmUnitTests, CheckDebugConstants) { |
| 347 | ASSERT_FALSE(kDumpWhenExpectMessageEqFails); |
| 348 | } |
| 349 | |
| 350 | // Expects the equality of `actual` and `expected` by inspecting a hard-coded |
| 351 | // subset of `audioproc::Stream` fields. |
| 352 | void ExpectStreamFieldsEq(const audioproc::Stream& actual, |
| 353 | const audioproc::Stream& expected) { |
| 354 | EXPECT_EQ(actual.input_data(), expected.input_data()); |
| 355 | EXPECT_EQ(actual.output_data(), expected.output_data()); |
| 356 | EXPECT_EQ(actual.delay(), expected.delay()); |
| 357 | EXPECT_EQ(actual.drift(), expected.drift()); |
Alessio Bazzica | 3153b36 | 2022-09-05 14:05:24 | [diff] [blame] | 358 | EXPECT_EQ(actual.applied_input_volume(), expected.applied_input_volume()); |
Alessio Bazzica | 85a126e | 2022-08-11 13:48:54 | [diff] [blame] | 359 | EXPECT_EQ(actual.keypress(), expected.keypress()); |
| 360 | } |
| 361 | |
| 362 | // Expects the equality of `actual` and `expected` by inspecting a hard-coded |
| 363 | // subset of `audioproc::Event` fields. |
| 364 | void ExpectEventFieldsEq(const audioproc::Event& actual, |
| 365 | const audioproc::Event& expected) { |
| 366 | EXPECT_EQ(actual.type(), expected.type()); |
| 367 | if (actual.type() != expected.type()) { |
| 368 | return; |
| 369 | } |
| 370 | switch (actual.type()) { |
| 371 | case audioproc::Event::STREAM: |
| 372 | ExpectStreamFieldsEq(actual.stream(), expected.stream()); |
| 373 | break; |
| 374 | default: |
| 375 | // Not implemented. |
| 376 | break; |
| 377 | } |
| 378 | } |
| 379 | |
| 380 | // Returns true if the `actual` and `expected` byte streams share the same size |
| 381 | // and contain the same data. If they differ and `kDumpWhenExpectMessageEqFails` |
| 382 | // is true, checks the equality of a subset of `audioproc::Event` (nested) |
| 383 | // fields. |
| 384 | bool ExpectMessageEq(rtc::ArrayView<const uint8_t> actual, |
| 385 | rtc::ArrayView<const uint8_t> expected) { |
| 386 | EXPECT_EQ(actual.size(), expected.size()); |
| 387 | if (actual.size() != expected.size()) { |
| 388 | return false; |
| 389 | } |
| 390 | if (memcmp(actual.data(), expected.data(), actual.size()) == 0) { |
| 391 | // Same message. No need to parse. |
| 392 | return true; |
| 393 | } |
| 394 | if (kDumpWhenExpectMessageEqFails) { |
| 395 | // Parse differing messages and expect equality to produce detailed error |
| 396 | // messages. |
| 397 | audioproc::Event event_actual, event_expected; |
| 398 | RTC_DCHECK(event_actual.ParseFromArray(actual.data(), actual.size())); |
| 399 | RTC_DCHECK(event_expected.ParseFromArray(expected.data(), expected.size())); |
| 400 | ExpectEventFieldsEq(event_actual, event_expected); |
| 401 | } |
| 402 | return false; |
| 403 | } |
| 404 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 405 | class ApmTest : public ::testing::Test { |
| 406 | protected: |
| 407 | ApmTest(); |
| 408 | virtual void SetUp(); |
| 409 | virtual void TearDown(); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 410 | |
Mirko Bonadei | 71061bc | 2019-06-04 07:01:51 | [diff] [blame] | 411 | static void SetUpTestSuite() {} |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 412 | |
Mirko Bonadei | 71061bc | 2019-06-04 07:01:51 | [diff] [blame] | 413 | static void TearDownTestSuite() { ClearTempFiles(); } |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 414 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 415 | // Used to select between int and float interface tests. |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 416 | enum Format { kIntFormat, kFloatFormat }; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 417 | |
| 418 | void Init(int sample_rate_hz, |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 419 | int output_sample_rate_hz, |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 420 | int reverse_sample_rate_hz, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 421 | size_t num_input_channels, |
| 422 | size_t num_output_channels, |
| 423 | size_t num_reverse_channels, |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 424 | bool open_output_file); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 425 | void Init(AudioProcessing* ap); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 426 | void EnableAllComponents(); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 427 | bool ReadFrame(FILE* file, Int16FrameData* frame); |
| 428 | bool ReadFrame(FILE* file, Int16FrameData* frame, ChannelBuffer<float>* cb); |
| 429 | void ReadFrameWithRewind(FILE* file, Int16FrameData* frame); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 430 | void ReadFrameWithRewind(FILE* file, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 431 | Int16FrameData* frame, |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 432 | ChannelBuffer<float>* cb); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 433 | void ProcessDelayVerificationTest(int delay_ms, |
| 434 | int system_delay_ms, |
| 435 | int delay_min, |
| 436 | int delay_max); |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 437 | void TestChangingChannelsInt16Interface( |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 438 | size_t num_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 439 | AudioProcessing::Error expected_return); |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 440 | void TestChangingForwardChannels(size_t num_in_channels, |
| 441 | size_t num_out_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 442 | AudioProcessing::Error expected_return); |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 443 | void TestChangingReverseChannels(size_t num_rev_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 444 | AudioProcessing::Error expected_return); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 445 | void RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate); |
| 446 | void RunManualVolumeChangeIsPossibleTest(int sample_rate); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 447 | void StreamParametersTest(Format format); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 448 | int ProcessStreamChooser(Format format); |
| 449 | int AnalyzeReverseStreamChooser(Format format); |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 450 | void ProcessDebugDump(absl::string_view in_filename, |
| 451 | absl::string_view out_filename, |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 452 | Format format, |
| 453 | int max_size_bytes); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 454 | void VerifyDebugDumpTest(Format format); |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 455 | |
| 456 | const std::string output_path_; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 457 | const std::string ref_filename_; |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 458 | rtc::scoped_refptr<AudioProcessing> apm_; |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 459 | Int16FrameData frame_; |
| 460 | Int16FrameData revframe_; |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 461 | std::unique_ptr<ChannelBuffer<float>> float_cb_; |
| 462 | std::unique_ptr<ChannelBuffer<float>> revfloat_cb_; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 463 | int output_sample_rate_hz_; |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 464 | size_t num_output_channels_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 465 | FILE* far_file_; |
| 466 | FILE* near_file_; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 467 | FILE* out_file_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 468 | }; |
| 469 | |
| 470 | ApmTest::ApmTest() |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 471 | : output_path_(test::OutputPath()), |
Per Åhgren | a43178c | 2020-09-25 10:02:32 | [diff] [blame] | 472 | ref_filename_(GetReferenceFilename()), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 473 | output_sample_rate_hz_(0), |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 474 | num_output_channels_(0), |
ajm@google.com | 22e6515 | 2011-07-18 18:03:01 | [diff] [blame] | 475 | far_file_(NULL), |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 476 | near_file_(NULL), |
aluebs@webrtc.org | c9ee412 | 2014-02-03 14:41:57 | [diff] [blame] | 477 | out_file_(NULL) { |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 478 | apm_ = AudioProcessingBuilderForTesting().Create(); |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 479 | AudioProcessing::Config apm_config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 480 | apm_config.gain_controller1.analog_gain_controller.enabled = false; |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 481 | apm_config.pipeline.maximum_internal_processing_rate = 48000; |
| 482 | apm_->ApplyConfig(apm_config); |
aluebs@webrtc.org | c9ee412 | 2014-02-03 14:41:57 | [diff] [blame] | 483 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 484 | |
| 485 | void ApmTest::SetUp() { |
andrew@webrtc.org | f3930e9 | 2013-09-18 22:37:32 | [diff] [blame] | 486 | ASSERT_TRUE(apm_.get() != NULL); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 487 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 488 | Init(32000, 32000, 32000, 2, 2, 2, false); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | void ApmTest::TearDown() { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 492 | if (far_file_) { |
| 493 | ASSERT_EQ(0, fclose(far_file_)); |
| 494 | } |
| 495 | far_file_ = NULL; |
| 496 | |
| 497 | if (near_file_) { |
| 498 | ASSERT_EQ(0, fclose(near_file_)); |
| 499 | } |
| 500 | near_file_ = NULL; |
| 501 | |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 502 | if (out_file_) { |
| 503 | ASSERT_EQ(0, fclose(out_file_)); |
| 504 | } |
| 505 | out_file_ = NULL; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 506 | } |
| 507 | |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 508 | void ApmTest::Init(AudioProcessing* ap) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 509 | ASSERT_EQ( |
| 510 | kNoErr, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 511 | ap->Initialize({{{frame_.sample_rate_hz, frame_.num_channels}, |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 512 | {output_sample_rate_hz_, num_output_channels_}, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 513 | {revframe_.sample_rate_hz, revframe_.num_channels}, |
| 514 | {revframe_.sample_rate_hz, revframe_.num_channels}}})); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 515 | } |
| 516 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 517 | void ApmTest::Init(int sample_rate_hz, |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 518 | int output_sample_rate_hz, |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 519 | int reverse_sample_rate_hz, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 520 | size_t num_input_channels, |
| 521 | size_t num_output_channels, |
| 522 | size_t num_reverse_channels, |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 523 | bool open_output_file) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 524 | SetContainerFormat(sample_rate_hz, num_input_channels, &frame_, &float_cb_); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 525 | output_sample_rate_hz_ = output_sample_rate_hz; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 526 | num_output_channels_ = num_output_channels; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 527 | |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 528 | SetContainerFormat(reverse_sample_rate_hz, num_reverse_channels, &revframe_, |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 529 | &revfloat_cb_); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 530 | Init(apm_.get()); |
andrew@webrtc.org | 60730cf | 2014-01-07 17:45:09 | [diff] [blame] | 531 | |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 532 | if (far_file_) { |
| 533 | ASSERT_EQ(0, fclose(far_file_)); |
| 534 | } |
| 535 | std::string filename = ResourceFilePath("far", sample_rate_hz); |
| 536 | far_file_ = fopen(filename.c_str(), "rb"); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 537 | ASSERT_TRUE(far_file_ != NULL) << "Could not open file " << filename << "\n"; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 538 | |
| 539 | if (near_file_) { |
| 540 | ASSERT_EQ(0, fclose(near_file_)); |
| 541 | } |
| 542 | filename = ResourceFilePath("near", sample_rate_hz); |
| 543 | near_file_ = fopen(filename.c_str(), "rb"); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 544 | ASSERT_TRUE(near_file_ != NULL) << "Could not open file " << filename << "\n"; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 545 | |
| 546 | if (open_output_file) { |
| 547 | if (out_file_) { |
| 548 | ASSERT_EQ(0, fclose(out_file_)); |
| 549 | } |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 550 | filename = OutputFilePath( |
| 551 | "out", sample_rate_hz, output_sample_rate_hz, reverse_sample_rate_hz, |
| 552 | reverse_sample_rate_hz, num_input_channels, num_output_channels, |
| 553 | num_reverse_channels, num_reverse_channels, kForward); |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 554 | out_file_ = fopen(filename.c_str(), "wb"); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 555 | ASSERT_TRUE(out_file_ != NULL) |
| 556 | << "Could not open file " << filename << "\n"; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 557 | } |
| 558 | } |
| 559 | |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 560 | void ApmTest::EnableAllComponents() { |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 561 | EnableAllAPComponents(apm_.get()); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 562 | } |
| 563 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 564 | bool ApmTest::ReadFrame(FILE* file, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 565 | Int16FrameData* frame, |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 566 | ChannelBuffer<float>* cb) { |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 567 | // The files always contain stereo audio. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 568 | size_t frame_size = frame->samples_per_channel * 2; |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 569 | size_t read_count = |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 570 | fread(frame->data.data(), sizeof(int16_t), frame_size, file); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 571 | if (read_count != frame_size) { |
| 572 | // Check that the file really ended. |
| 573 | EXPECT_NE(0, feof(file)); |
| 574 | return false; // This is expected. |
| 575 | } |
| 576 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 577 | if (frame->num_channels == 1) { |
| 578 | MixStereoToMono(frame->data.data(), frame->data.data(), |
| 579 | frame->samples_per_channel); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 580 | } |
| 581 | |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 582 | if (cb) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 583 | ConvertToFloat(*frame, cb); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 584 | } |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 585 | return true; |
ajm@google.com | a769fa5 | 2011-07-13 21:57:58 | [diff] [blame] | 586 | } |
| 587 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 588 | bool ApmTest::ReadFrame(FILE* file, Int16FrameData* frame) { |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 589 | return ReadFrame(file, frame, NULL); |
| 590 | } |
| 591 | |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 592 | // If the end of the file has been reached, rewind it and attempt to read the |
| 593 | // frame again. |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 594 | void ApmTest::ReadFrameWithRewind(FILE* file, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 595 | Int16FrameData* frame, |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 596 | ChannelBuffer<float>* cb) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 597 | if (!ReadFrame(near_file_, &frame_, cb)) { |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 598 | rewind(near_file_); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 599 | ASSERT_TRUE(ReadFrame(near_file_, &frame_, cb)); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 600 | } |
| 601 | } |
| 602 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 603 | void ApmTest::ReadFrameWithRewind(FILE* file, Int16FrameData* frame) { |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 604 | ReadFrameWithRewind(file, frame, NULL); |
| 605 | } |
| 606 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 607 | int ApmTest::ProcessStreamChooser(Format format) { |
| 608 | if (format == kIntFormat) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 609 | return apm_->ProcessStream( |
| 610 | frame_.data.data(), |
| 611 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 612 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 613 | frame_.data.data()); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 614 | } |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 615 | return apm_->ProcessStream( |
Gustaf Ullberg | cb30726 | 2019-10-29 08:30:44 | [diff] [blame] | 616 | float_cb_->channels(), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 617 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Gustaf Ullberg | cb30726 | 2019-10-29 08:30:44 | [diff] [blame] | 618 | StreamConfig(output_sample_rate_hz_, num_output_channels_), |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 619 | float_cb_->channels()); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 620 | } |
| 621 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 622 | int ApmTest::AnalyzeReverseStreamChooser(Format format) { |
| 623 | if (format == kIntFormat) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 624 | return apm_->ProcessReverseStream( |
| 625 | revframe_.data.data(), |
| 626 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 627 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 628 | revframe_.data.data()); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 629 | } |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 630 | return apm_->AnalyzeReverseStream( |
Gustaf Ullberg | cb30726 | 2019-10-29 08:30:44 | [diff] [blame] | 631 | revfloat_cb_->channels(), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 632 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels)); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 633 | } |
| 634 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 635 | void ApmTest::ProcessDelayVerificationTest(int delay_ms, |
| 636 | int system_delay_ms, |
| 637 | int delay_min, |
| 638 | int delay_max) { |
Artem Titov | 0b48930 | 2021-07-28 18:50:03 | [diff] [blame] | 639 | // The `revframe_` and `frame_` should include the proper frame information, |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 640 | // hence can be used for extracting information. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 641 | Int16FrameData tmp_frame; |
| 642 | std::queue<Int16FrameData*> frame_queue; |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 643 | bool causal = true; |
| 644 | |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 645 | tmp_frame.CopyFrom(revframe_); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 646 | SetFrameTo(&tmp_frame, 0); |
| 647 | |
| 648 | EXPECT_EQ(apm_->kNoError, apm_->Initialize()); |
Artem Titov | 0b48930 | 2021-07-28 18:50:03 | [diff] [blame] | 649 | // Initialize the `frame_queue` with empty frames. |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 650 | int frame_delay = delay_ms / 10; |
| 651 | while (frame_delay < 0) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 652 | Int16FrameData* frame = new Int16FrameData(); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 653 | frame->CopyFrom(tmp_frame); |
| 654 | frame_queue.push(frame); |
| 655 | frame_delay++; |
| 656 | causal = false; |
| 657 | } |
| 658 | while (frame_delay > 0) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 659 | Int16FrameData* frame = new Int16FrameData(); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 660 | frame->CopyFrom(tmp_frame); |
| 661 | frame_queue.push(frame); |
| 662 | frame_delay--; |
| 663 | } |
bjornv@webrtc.org | bbd47fc | 2014-01-13 08:54:34 | [diff] [blame] | 664 | // Run for 4.5 seconds, skipping statistics from the first 2.5 seconds. We |
| 665 | // need enough frames with audio to have reliable estimates, but as few as |
| 666 | // possible to keep processing time down. 4.5 seconds seemed to be a good |
| 667 | // compromise for this recording. |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 668 | for (int frame_count = 0; frame_count < 450; ++frame_count) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 669 | Int16FrameData* frame = new Int16FrameData(); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 670 | frame->CopyFrom(tmp_frame); |
| 671 | // Use the near end recording, since that has more speech in it. |
| 672 | ASSERT_TRUE(ReadFrame(near_file_, frame)); |
| 673 | frame_queue.push(frame); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 674 | Int16FrameData* reverse_frame = frame; |
| 675 | Int16FrameData* process_frame = frame_queue.front(); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 676 | if (!causal) { |
| 677 | reverse_frame = frame_queue.front(); |
| 678 | // When we call ProcessStream() the frame is modified, so we can't use the |
| 679 | // pointer directly when things are non-causal. Use an intermediate frame |
| 680 | // and copy the data. |
| 681 | process_frame = &tmp_frame; |
| 682 | process_frame->CopyFrom(*frame); |
| 683 | } |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 684 | EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream( |
| 685 | reverse_frame->data.data(), |
| 686 | StreamConfig(reverse_frame->sample_rate_hz, |
| 687 | reverse_frame->num_channels), |
| 688 | StreamConfig(reverse_frame->sample_rate_hz, |
| 689 | reverse_frame->num_channels), |
| 690 | reverse_frame->data.data())); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 691 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(system_delay_ms)); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 692 | EXPECT_EQ(apm_->kNoError, |
| 693 | apm_->ProcessStream(process_frame->data.data(), |
| 694 | StreamConfig(process_frame->sample_rate_hz, |
| 695 | process_frame->num_channels), |
| 696 | StreamConfig(process_frame->sample_rate_hz, |
| 697 | process_frame->num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 698 | process_frame->data.data())); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 699 | frame = frame_queue.front(); |
| 700 | frame_queue.pop(); |
| 701 | delete frame; |
| 702 | |
bjornv@webrtc.org | bbd47fc | 2014-01-13 08:54:34 | [diff] [blame] | 703 | if (frame_count == 250) { |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 704 | // Discard the first delay metrics to avoid convergence effects. |
Per Åhgren | cf4c872 | 2019-12-30 13:32:14 | [diff] [blame] | 705 | static_cast<void>(apm_->GetStatistics()); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 706 | } |
| 707 | } |
| 708 | |
| 709 | rewind(near_file_); |
| 710 | while (!frame_queue.empty()) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 711 | Int16FrameData* frame = frame_queue.front(); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 712 | frame_queue.pop(); |
| 713 | delete frame; |
| 714 | } |
| 715 | // Calculate expected delay estimate and acceptable regions. Further, |
| 716 | // limit them w.r.t. AEC delay estimation support. |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 717 | const size_t samples_per_ms = |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 718 | rtc::SafeMin<size_t>(16u, frame_.samples_per_channel / 10); |
kwiberg | 0703856 | 2017-06-12 18:40:47 | [diff] [blame] | 719 | const int expected_median = |
| 720 | rtc::SafeClamp<int>(delay_ms - system_delay_ms, delay_min, delay_max); |
| 721 | const int expected_median_high = rtc::SafeClamp<int>( |
| 722 | expected_median + rtc::dchecked_cast<int>(96 / samples_per_ms), delay_min, |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 723 | delay_max); |
kwiberg | 0703856 | 2017-06-12 18:40:47 | [diff] [blame] | 724 | const int expected_median_low = rtc::SafeClamp<int>( |
| 725 | expected_median - rtc::dchecked_cast<int>(96 / samples_per_ms), delay_min, |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 726 | delay_max); |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 727 | // Verify delay metrics. |
Per Åhgren | cf4c872 | 2019-12-30 13:32:14 | [diff] [blame] | 728 | AudioProcessingStats stats = apm_->GetStatistics(); |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 729 | ASSERT_TRUE(stats.delay_median_ms.has_value()); |
| 730 | int32_t median = *stats.delay_median_ms; |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 731 | EXPECT_GE(expected_median_high, median); |
| 732 | EXPECT_LE(expected_median_low, median); |
| 733 | } |
| 734 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 735 | void ApmTest::StreamParametersTest(Format format) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 736 | // No errors when the components are disabled. |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 737 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 738 | |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 739 | // -- Missing AGC level -- |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 740 | AudioProcessing::Config apm_config = apm_->GetConfig(); |
| 741 | apm_config.gain_controller1.enabled = true; |
| 742 | apm_->ApplyConfig(apm_config); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 743 | EXPECT_EQ(apm_->kStreamParameterNotSetError, ProcessStreamChooser(format)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 744 | |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 745 | // Resets after successful ProcessStream(). |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 746 | apm_->set_stream_analog_level(127); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 747 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 748 | EXPECT_EQ(apm_->kStreamParameterNotSetError, ProcessStreamChooser(format)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 749 | |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 750 | // Other stream parameters set correctly. |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 751 | apm_config.echo_canceller.enabled = true; |
| 752 | apm_config.echo_canceller.mobile_mode = false; |
| 753 | apm_->ApplyConfig(apm_config); |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 754 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100)); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 755 | EXPECT_EQ(apm_->kStreamParameterNotSetError, ProcessStreamChooser(format)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 756 | apm_config.gain_controller1.enabled = false; |
| 757 | apm_->ApplyConfig(apm_config); |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 758 | |
| 759 | // -- Missing delay -- |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 760 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 761 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 762 | |
| 763 | // Resets after successful ProcessStream(). |
| 764 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100)); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 765 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 766 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 767 | |
| 768 | // Other stream parameters set correctly. |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 769 | apm_config.gain_controller1.enabled = true; |
| 770 | apm_->ApplyConfig(apm_config); |
| 771 | apm_->set_stream_analog_level(127); |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 772 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 773 | apm_config.gain_controller1.enabled = false; |
| 774 | apm_->ApplyConfig(apm_config); |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 775 | |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 776 | // -- No stream parameters -- |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 777 | EXPECT_EQ(apm_->kNoError, AnalyzeReverseStreamChooser(format)); |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 778 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 779 | |
andrew@webrtc.org | 1e91693 | 2011-11-29 18:28:57 | [diff] [blame] | 780 | // -- All there -- |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 781 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(100)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 782 | apm_->set_stream_analog_level(127); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 783 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(format)); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 784 | } |
| 785 | |
| 786 | TEST_F(ApmTest, StreamParametersInt) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 787 | StreamParametersTest(kIntFormat); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 788 | } |
| 789 | |
| 790 | TEST_F(ApmTest, StreamParametersFloat) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 791 | StreamParametersTest(kFloatFormat); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 792 | } |
| 793 | |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 794 | void ApmTest::TestChangingChannelsInt16Interface( |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 795 | size_t num_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 796 | AudioProcessing::Error expected_return) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 797 | frame_.num_channels = num_channels; |
| 798 | |
| 799 | EXPECT_EQ(expected_return, |
| 800 | apm_->ProcessStream( |
| 801 | frame_.data.data(), |
| 802 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 803 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 804 | frame_.data.data())); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 805 | EXPECT_EQ(expected_return, |
| 806 | apm_->ProcessReverseStream( |
| 807 | frame_.data.data(), |
| 808 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 809 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 810 | frame_.data.data())); |
andrew@webrtc.org | 60730cf | 2014-01-07 17:45:09 | [diff] [blame] | 811 | } |
| 812 | |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 813 | void ApmTest::TestChangingForwardChannels( |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 814 | size_t num_in_channels, |
| 815 | size_t num_out_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 816 | AudioProcessing::Error expected_return) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 817 | const StreamConfig input_stream = {frame_.sample_rate_hz, num_in_channels}; |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 818 | const StreamConfig output_stream = {output_sample_rate_hz_, num_out_channels}; |
| 819 | |
| 820 | EXPECT_EQ(expected_return, |
| 821 | apm_->ProcessStream(float_cb_->channels(), input_stream, |
| 822 | output_stream, float_cb_->channels())); |
| 823 | } |
| 824 | |
| 825 | void ApmTest::TestChangingReverseChannels( |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 826 | size_t num_rev_channels, |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 827 | AudioProcessing::Error expected_return) { |
| 828 | const ProcessingConfig processing_config = { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 829 | {{frame_.sample_rate_hz, apm_->num_input_channels()}, |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 830 | {output_sample_rate_hz_, apm_->num_output_channels()}, |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 831 | {frame_.sample_rate_hz, num_rev_channels}, |
| 832 | {frame_.sample_rate_hz, num_rev_channels}}}; |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 833 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 834 | EXPECT_EQ( |
| 835 | expected_return, |
| 836 | apm_->ProcessReverseStream( |
| 837 | float_cb_->channels(), processing_config.reverse_input_stream(), |
| 838 | processing_config.reverse_output_stream(), float_cb_->channels())); |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 839 | } |
| 840 | |
| 841 | TEST_F(ApmTest, ChannelsInt16Interface) { |
| 842 | // Testing number of invalid and valid channels. |
| 843 | Init(16000, 16000, 16000, 4, 4, 4, false); |
| 844 | |
| 845 | TestChangingChannelsInt16Interface(0, apm_->kBadNumberChannelsError); |
| 846 | |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 847 | for (size_t i = 1; i < 4; i++) { |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 848 | TestChangingChannelsInt16Interface(i, kNoErr); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 849 | EXPECT_EQ(i, apm_->num_input_channels()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 850 | } |
| 851 | } |
| 852 | |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 853 | TEST_F(ApmTest, Channels) { |
| 854 | // Testing number of invalid and valid channels. |
| 855 | Init(16000, 16000, 16000, 4, 4, 4, false); |
| 856 | |
| 857 | TestChangingForwardChannels(0, 1, apm_->kBadNumberChannelsError); |
| 858 | TestChangingReverseChannels(0, apm_->kBadNumberChannelsError); |
| 859 | |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 860 | for (size_t i = 1; i < 4; ++i) { |
| 861 | for (size_t j = 0; j < 1; ++j) { |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 862 | // Output channels much be one or match input channels. |
| 863 | if (j == 1 || i == j) { |
| 864 | TestChangingForwardChannels(i, j, kNoErr); |
| 865 | TestChangingReverseChannels(i, kNoErr); |
| 866 | |
| 867 | EXPECT_EQ(i, apm_->num_input_channels()); |
| 868 | EXPECT_EQ(j, apm_->num_output_channels()); |
| 869 | // The number of reverse channels used for processing to is always 1. |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 870 | EXPECT_EQ(1u, apm_->num_reverse_channels()); |
Michael Graczyk | 86c6d33 | 2015-07-23 18:41:39 | [diff] [blame] | 871 | } else { |
| 872 | TestChangingForwardChannels(i, j, |
| 873 | AudioProcessing::kBadNumberChannelsError); |
| 874 | } |
| 875 | } |
| 876 | } |
| 877 | } |
| 878 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 879 | TEST_F(ApmTest, SampleRatesInt) { |
Sam Zackrisson | 12e319a | 2020-01-03 13:54:20 | [diff] [blame] | 880 | // Testing some valid sample rates. |
| 881 | for (int sample_rate : {8000, 12000, 16000, 32000, 44100, 48000, 96000}) { |
| 882 | SetContainerFormat(sample_rate, 2, &frame_, &float_cb_); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 883 | EXPECT_NOERR(ProcessStreamChooser(kIntFormat)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 884 | } |
| 885 | } |
| 886 | |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 887 | // This test repeatedly reconfigures the pre-amplifier in APM, processes a |
| 888 | // number of frames, and checks that output signal has the right level. |
| 889 | TEST_F(ApmTest, PreAmplifier) { |
| 890 | // Fill the audio frame with a sawtooth pattern. |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 891 | rtc::ArrayView<int16_t> frame_data = GetMutableFrameData(&frame_); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 892 | const size_t samples_per_channel = frame_.samples_per_channel; |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 893 | for (size_t i = 0; i < samples_per_channel; i++) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 894 | for (size_t ch = 0; ch < frame_.num_channels; ++ch) { |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 895 | frame_data[i + ch * samples_per_channel] = 10000 * ((i % 3) - 1); |
| 896 | } |
| 897 | } |
| 898 | // Cache the frame in tmp_frame. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 899 | Int16FrameData tmp_frame; |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 900 | tmp_frame.CopyFrom(frame_); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 901 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 902 | auto compute_power = [](const Int16FrameData& frame) { |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 903 | rtc::ArrayView<const int16_t> data = GetFrameData(frame); |
| 904 | return std::accumulate(data.begin(), data.end(), 0.0f, |
| 905 | [](float a, float b) { return a + b * b; }) / |
| 906 | data.size() / 32768 / 32768; |
| 907 | }; |
| 908 | |
| 909 | const float input_power = compute_power(tmp_frame); |
| 910 | // Double-check that the input data is large compared to the error kEpsilon. |
| 911 | constexpr float kEpsilon = 1e-4f; |
| 912 | RTC_DCHECK_GE(input_power, 10 * kEpsilon); |
| 913 | |
| 914 | // 1. Enable pre-amp with 0 dB gain. |
| 915 | AudioProcessing::Config config = apm_->GetConfig(); |
| 916 | config.pre_amplifier.enabled = true; |
| 917 | config.pre_amplifier.fixed_gain_factor = 1.0f; |
| 918 | apm_->ApplyConfig(config); |
| 919 | |
| 920 | for (int i = 0; i < 20; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 921 | frame_.CopyFrom(tmp_frame); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 922 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 923 | } |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 924 | float output_power = compute_power(frame_); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 925 | EXPECT_NEAR(output_power, input_power, kEpsilon); |
| 926 | config = apm_->GetConfig(); |
| 927 | EXPECT_EQ(config.pre_amplifier.fixed_gain_factor, 1.0f); |
| 928 | |
| 929 | // 2. Change pre-amp gain via ApplyConfig. |
| 930 | config.pre_amplifier.fixed_gain_factor = 2.0f; |
| 931 | apm_->ApplyConfig(config); |
| 932 | |
| 933 | for (int i = 0; i < 20; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 934 | frame_.CopyFrom(tmp_frame); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 935 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 936 | } |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 937 | output_power = compute_power(frame_); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 938 | EXPECT_NEAR(output_power, 4 * input_power, kEpsilon); |
| 939 | config = apm_->GetConfig(); |
| 940 | EXPECT_EQ(config.pre_amplifier.fixed_gain_factor, 2.0f); |
| 941 | |
| 942 | // 3. Change pre-amp gain via a RuntimeSetting. |
| 943 | apm_->SetRuntimeSetting( |
| 944 | AudioProcessing::RuntimeSetting::CreateCapturePreGain(1.5f)); |
| 945 | |
| 946 | for (int i = 0; i < 20; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 947 | frame_.CopyFrom(tmp_frame); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 948 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 949 | } |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 950 | output_power = compute_power(frame_); |
Sam Zackrisson | e277bde | 2019-10-25 08:07:54 | [diff] [blame] | 951 | EXPECT_NEAR(output_power, 2.25 * input_power, kEpsilon); |
| 952 | config = apm_->GetConfig(); |
| 953 | EXPECT_EQ(config.pre_amplifier.fixed_gain_factor, 1.5f); |
| 954 | } |
| 955 | |
Alessio Bazzica | fcf1af3 | 2022-09-07 15:14:26 | [diff] [blame] | 956 | // Ensures that the emulated analog mic gain functionality runs without |
| 957 | // crashing. |
Per Åhgren | db5d728 | 2021-03-15 16:31:04 | [diff] [blame] | 958 | TEST_F(ApmTest, AnalogMicGainEmulation) { |
| 959 | // Fill the audio frame with a sawtooth pattern. |
| 960 | rtc::ArrayView<int16_t> frame_data = GetMutableFrameData(&frame_); |
| 961 | const size_t samples_per_channel = frame_.samples_per_channel; |
| 962 | for (size_t i = 0; i < samples_per_channel; i++) { |
| 963 | for (size_t ch = 0; ch < frame_.num_channels; ++ch) { |
| 964 | frame_data[i + ch * samples_per_channel] = 100 * ((i % 3) - 1); |
| 965 | } |
| 966 | } |
| 967 | // Cache the frame in tmp_frame. |
| 968 | Int16FrameData tmp_frame; |
| 969 | tmp_frame.CopyFrom(frame_); |
| 970 | |
| 971 | // Enable the analog gain emulation. |
| 972 | AudioProcessing::Config config = apm_->GetConfig(); |
| 973 | config.capture_level_adjustment.enabled = true; |
| 974 | config.capture_level_adjustment.analog_mic_gain_emulation.enabled = true; |
| 975 | config.capture_level_adjustment.analog_mic_gain_emulation.initial_level = 21; |
| 976 | config.gain_controller1.enabled = true; |
| 977 | config.gain_controller1.mode = |
| 978 | AudioProcessing::Config::GainController1::Mode::kAdaptiveAnalog; |
| 979 | config.gain_controller1.analog_gain_controller.enabled = true; |
| 980 | apm_->ApplyConfig(config); |
| 981 | |
| 982 | // Process a number of frames to ensure that the code runs without crashes. |
| 983 | for (int i = 0; i < 20; ++i) { |
| 984 | frame_.CopyFrom(tmp_frame); |
| 985 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 986 | } |
| 987 | } |
| 988 | |
| 989 | // This test repeatedly reconfigures the capture level adjustment functionality |
| 990 | // in APM, processes a number of frames, and checks that output signal has the |
| 991 | // right level. |
| 992 | TEST_F(ApmTest, CaptureLevelAdjustment) { |
| 993 | // Fill the audio frame with a sawtooth pattern. |
| 994 | rtc::ArrayView<int16_t> frame_data = GetMutableFrameData(&frame_); |
| 995 | const size_t samples_per_channel = frame_.samples_per_channel; |
| 996 | for (size_t i = 0; i < samples_per_channel; i++) { |
| 997 | for (size_t ch = 0; ch < frame_.num_channels; ++ch) { |
| 998 | frame_data[i + ch * samples_per_channel] = 100 * ((i % 3) - 1); |
| 999 | } |
| 1000 | } |
| 1001 | // Cache the frame in tmp_frame. |
| 1002 | Int16FrameData tmp_frame; |
| 1003 | tmp_frame.CopyFrom(frame_); |
| 1004 | |
| 1005 | auto compute_power = [](const Int16FrameData& frame) { |
| 1006 | rtc::ArrayView<const int16_t> data = GetFrameData(frame); |
| 1007 | return std::accumulate(data.begin(), data.end(), 0.0f, |
| 1008 | [](float a, float b) { return a + b * b; }) / |
| 1009 | data.size() / 32768 / 32768; |
| 1010 | }; |
| 1011 | |
| 1012 | const float input_power = compute_power(tmp_frame); |
| 1013 | // Double-check that the input data is large compared to the error kEpsilon. |
| 1014 | constexpr float kEpsilon = 1e-20f; |
| 1015 | RTC_DCHECK_GE(input_power, 10 * kEpsilon); |
| 1016 | |
| 1017 | // 1. Enable pre-amp with 0 dB gain. |
| 1018 | AudioProcessing::Config config = apm_->GetConfig(); |
| 1019 | config.capture_level_adjustment.enabled = true; |
| 1020 | config.capture_level_adjustment.pre_gain_factor = 0.5f; |
| 1021 | config.capture_level_adjustment.post_gain_factor = 4.f; |
| 1022 | const float expected_output_power1 = |
| 1023 | config.capture_level_adjustment.pre_gain_factor * |
| 1024 | config.capture_level_adjustment.pre_gain_factor * |
| 1025 | config.capture_level_adjustment.post_gain_factor * |
| 1026 | config.capture_level_adjustment.post_gain_factor * input_power; |
| 1027 | apm_->ApplyConfig(config); |
| 1028 | |
| 1029 | for (int i = 0; i < 20; ++i) { |
| 1030 | frame_.CopyFrom(tmp_frame); |
| 1031 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 1032 | } |
| 1033 | float output_power = compute_power(frame_); |
| 1034 | EXPECT_NEAR(output_power, expected_output_power1, kEpsilon); |
| 1035 | config = apm_->GetConfig(); |
| 1036 | EXPECT_EQ(config.capture_level_adjustment.pre_gain_factor, 0.5f); |
| 1037 | EXPECT_EQ(config.capture_level_adjustment.post_gain_factor, 4.f); |
| 1038 | |
| 1039 | // 2. Change pre-amp gain via ApplyConfig. |
| 1040 | config.capture_level_adjustment.pre_gain_factor = 1.0f; |
| 1041 | config.capture_level_adjustment.post_gain_factor = 2.f; |
| 1042 | const float expected_output_power2 = |
| 1043 | config.capture_level_adjustment.pre_gain_factor * |
| 1044 | config.capture_level_adjustment.pre_gain_factor * |
| 1045 | config.capture_level_adjustment.post_gain_factor * |
| 1046 | config.capture_level_adjustment.post_gain_factor * input_power; |
| 1047 | apm_->ApplyConfig(config); |
| 1048 | |
| 1049 | for (int i = 0; i < 20; ++i) { |
| 1050 | frame_.CopyFrom(tmp_frame); |
| 1051 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 1052 | } |
| 1053 | output_power = compute_power(frame_); |
| 1054 | EXPECT_NEAR(output_power, expected_output_power2, kEpsilon); |
| 1055 | config = apm_->GetConfig(); |
| 1056 | EXPECT_EQ(config.capture_level_adjustment.pre_gain_factor, 1.0f); |
| 1057 | EXPECT_EQ(config.capture_level_adjustment.post_gain_factor, 2.f); |
| 1058 | |
| 1059 | // 3. Change pre-amp gain via a RuntimeSetting. |
| 1060 | constexpr float kPreGain3 = 0.5f; |
| 1061 | constexpr float kPostGain3 = 3.f; |
| 1062 | const float expected_output_power3 = |
| 1063 | kPreGain3 * kPreGain3 * kPostGain3 * kPostGain3 * input_power; |
| 1064 | |
| 1065 | apm_->SetRuntimeSetting( |
| 1066 | AudioProcessing::RuntimeSetting::CreateCapturePreGain(kPreGain3)); |
| 1067 | apm_->SetRuntimeSetting( |
| 1068 | AudioProcessing::RuntimeSetting::CreateCapturePostGain(kPostGain3)); |
| 1069 | |
| 1070 | for (int i = 0; i < 20; ++i) { |
| 1071 | frame_.CopyFrom(tmp_frame); |
| 1072 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kIntFormat)); |
| 1073 | } |
| 1074 | output_power = compute_power(frame_); |
| 1075 | EXPECT_NEAR(output_power, expected_output_power3, kEpsilon); |
| 1076 | config = apm_->GetConfig(); |
| 1077 | EXPECT_EQ(config.capture_level_adjustment.pre_gain_factor, 0.5f); |
| 1078 | EXPECT_EQ(config.capture_level_adjustment.post_gain_factor, 3.f); |
| 1079 | } |
| 1080 | |
aluebs@webrtc.org | c9ee412 | 2014-02-03 14:41:57 | [diff] [blame] | 1081 | TEST_F(ApmTest, GainControl) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1082 | AudioProcessing::Config config = apm_->GetConfig(); |
| 1083 | config.gain_controller1.enabled = false; |
| 1084 | apm_->ApplyConfig(config); |
| 1085 | config.gain_controller1.enabled = true; |
| 1086 | apm_->ApplyConfig(config); |
| 1087 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1088 | // Testing gain modes |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1089 | for (auto mode : |
| 1090 | {AudioProcessing::Config::GainController1::kAdaptiveDigital, |
| 1091 | AudioProcessing::Config::GainController1::kFixedDigital, |
| 1092 | AudioProcessing::Config::GainController1::kAdaptiveAnalog}) { |
| 1093 | config.gain_controller1.mode = mode; |
| 1094 | apm_->ApplyConfig(config); |
| 1095 | apm_->set_stream_analog_level(100); |
| 1096 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1097 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1098 | |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1099 | // Testing target levels |
| 1100 | for (int target_level_dbfs : {0, 15, 31}) { |
| 1101 | config.gain_controller1.target_level_dbfs = target_level_dbfs; |
| 1102 | apm_->ApplyConfig(config); |
| 1103 | apm_->set_stream_analog_level(100); |
| 1104 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1105 | } |
| 1106 | |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1107 | // Testing compression gains |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1108 | for (int compression_gain_db : {0, 10, 90}) { |
| 1109 | config.gain_controller1.compression_gain_db = compression_gain_db; |
| 1110 | apm_->ApplyConfig(config); |
| 1111 | apm_->set_stream_analog_level(100); |
| 1112 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1113 | } |
| 1114 | |
| 1115 | // Testing limiter off/on |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1116 | for (bool enable : {false, true}) { |
| 1117 | config.gain_controller1.enable_limiter = enable; |
| 1118 | apm_->ApplyConfig(config); |
| 1119 | apm_->set_stream_analog_level(100); |
| 1120 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
| 1121 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1122 | |
Hanna Silen | cd59704 | 2021-11-02 10:02:48 | [diff] [blame] | 1123 | // Testing level limits. |
| 1124 | constexpr int kMinLevel = 0; |
| 1125 | constexpr int kMaxLevel = 255; |
| 1126 | apm_->set_stream_analog_level(kMinLevel); |
| 1127 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
| 1128 | apm_->set_stream_analog_level((kMinLevel + kMaxLevel) / 2); |
| 1129 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
| 1130 | apm_->set_stream_analog_level(kMaxLevel); |
| 1131 | EXPECT_EQ(apm_->kNoError, ProcessStreamChooser(kFloatFormat)); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1132 | } |
| 1133 | |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1134 | #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1135 | using ApmDeathTest = ApmTest; |
| 1136 | |
| 1137 | TEST_F(ApmDeathTest, GainControlDiesOnTooLowTargetLevelDbfs) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1138 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1139 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1140 | config.gain_controller1.target_level_dbfs = -1; |
| 1141 | EXPECT_DEATH(apm_->ApplyConfig(config), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1142 | } |
| 1143 | |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1144 | TEST_F(ApmDeathTest, GainControlDiesOnTooHighTargetLevelDbfs) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1145 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1146 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1147 | config.gain_controller1.target_level_dbfs = 32; |
| 1148 | EXPECT_DEATH(apm_->ApplyConfig(config), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1149 | } |
| 1150 | |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1151 | TEST_F(ApmDeathTest, GainControlDiesOnTooLowCompressionGainDb) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1152 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1153 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1154 | config.gain_controller1.compression_gain_db = -1; |
| 1155 | EXPECT_DEATH(apm_->ApplyConfig(config), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1156 | } |
| 1157 | |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1158 | TEST_F(ApmDeathTest, GainControlDiesOnTooHighCompressionGainDb) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1159 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1160 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1161 | config.gain_controller1.compression_gain_db = 91; |
| 1162 | EXPECT_DEATH(apm_->ApplyConfig(config), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1163 | } |
| 1164 | |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1165 | TEST_F(ApmDeathTest, ApmDiesOnTooLowAnalogLevel) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1166 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1167 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1168 | apm_->ApplyConfig(config); |
Hanna Silen | cd59704 | 2021-11-02 10:02:48 | [diff] [blame] | 1169 | EXPECT_DEATH(apm_->set_stream_analog_level(-1), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1170 | } |
| 1171 | |
Tommi | a5e07cc | 2020-05-26 19:40:37 | [diff] [blame] | 1172 | TEST_F(ApmDeathTest, ApmDiesOnTooHighAnalogLevel) { |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1173 | auto config = apm_->GetConfig(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1174 | config.gain_controller1.enabled = true; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1175 | apm_->ApplyConfig(config); |
Hanna Silen | cd59704 | 2021-11-02 10:02:48 | [diff] [blame] | 1176 | EXPECT_DEATH(apm_->set_stream_analog_level(256), ""); |
Sam Zackrisson | f0d1c03 | 2019-03-27 12:28:08 | [diff] [blame] | 1177 | } |
| 1178 | #endif |
| 1179 | |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1180 | void ApmTest::RunQuantizedVolumeDoesNotGetStuckTest(int sample_rate) { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1181 | Init(sample_rate, sample_rate, sample_rate, 2, 2, 2, false); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1182 | auto config = apm_->GetConfig(); |
| 1183 | config.gain_controller1.enabled = true; |
| 1184 | config.gain_controller1.mode = |
| 1185 | AudioProcessing::Config::GainController1::kAdaptiveAnalog; |
| 1186 | apm_->ApplyConfig(config); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1187 | |
| 1188 | int out_analog_level = 0; |
| 1189 | for (int i = 0; i < 2000; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1190 | ReadFrameWithRewind(near_file_, &frame_); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1191 | // Ensure the audio is at a low level, so the AGC will try to increase it. |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1192 | ScaleFrame(&frame_, 0.25); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1193 | |
| 1194 | // Always pass in the same volume. |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1195 | apm_->set_stream_analog_level(100); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1196 | EXPECT_EQ(apm_->kNoError, |
| 1197 | apm_->ProcessStream( |
| 1198 | frame_.data.data(), |
| 1199 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1200 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1201 | frame_.data.data())); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1202 | out_analog_level = apm_->recommended_stream_analog_level(); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1203 | } |
| 1204 | |
| 1205 | // Ensure the AGC is still able to reach the maximum. |
| 1206 | EXPECT_EQ(255, out_analog_level); |
| 1207 | } |
| 1208 | |
| 1209 | // Verifies that despite volume slider quantization, the AGC can continue to |
| 1210 | // increase its volume. |
| 1211 | TEST_F(ApmTest, QuantizedVolumeDoesNotGetStuck) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1212 | for (size_t sample_rate_hz : kProcessSampleRates) { |
| 1213 | SCOPED_TRACE(::testing::Message() << "sample_rate_hz=" << sample_rate_hz); |
| 1214 | RunQuantizedVolumeDoesNotGetStuckTest(sample_rate_hz); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1215 | } |
| 1216 | } |
| 1217 | |
| 1218 | void ApmTest::RunManualVolumeChangeIsPossibleTest(int sample_rate) { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1219 | Init(sample_rate, sample_rate, sample_rate, 2, 2, 2, false); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1220 | auto config = apm_->GetConfig(); |
| 1221 | config.gain_controller1.enabled = true; |
| 1222 | config.gain_controller1.mode = |
| 1223 | AudioProcessing::Config::GainController1::kAdaptiveAnalog; |
| 1224 | apm_->ApplyConfig(config); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1225 | |
| 1226 | int out_analog_level = 100; |
| 1227 | for (int i = 0; i < 1000; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1228 | ReadFrameWithRewind(near_file_, &frame_); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1229 | // Ensure the audio is at a low level, so the AGC will try to increase it. |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1230 | ScaleFrame(&frame_, 0.25); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1231 | |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1232 | apm_->set_stream_analog_level(out_analog_level); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1233 | EXPECT_EQ(apm_->kNoError, |
| 1234 | apm_->ProcessStream( |
| 1235 | frame_.data.data(), |
| 1236 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1237 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1238 | frame_.data.data())); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1239 | out_analog_level = apm_->recommended_stream_analog_level(); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1240 | } |
| 1241 | |
| 1242 | // Ensure the volume was raised. |
| 1243 | EXPECT_GT(out_analog_level, 100); |
| 1244 | int highest_level_reached = out_analog_level; |
| 1245 | // Simulate a user manual volume change. |
| 1246 | out_analog_level = 100; |
| 1247 | |
| 1248 | for (int i = 0; i < 300; ++i) { |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1249 | ReadFrameWithRewind(near_file_, &frame_); |
| 1250 | ScaleFrame(&frame_, 0.25); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1251 | |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1252 | apm_->set_stream_analog_level(out_analog_level); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1253 | EXPECT_EQ(apm_->kNoError, |
| 1254 | apm_->ProcessStream( |
| 1255 | frame_.data.data(), |
| 1256 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1257 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1258 | frame_.data.data())); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1259 | out_analog_level = apm_->recommended_stream_analog_level(); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1260 | // Check that AGC respected the manually adjusted volume. |
| 1261 | EXPECT_LT(out_analog_level, highest_level_reached); |
| 1262 | } |
| 1263 | // Check that the volume was still raised. |
| 1264 | EXPECT_GT(out_analog_level, 100); |
| 1265 | } |
| 1266 | |
| 1267 | TEST_F(ApmTest, ManualVolumeChangeIsPossible) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1268 | for (size_t sample_rate_hz : kProcessSampleRates) { |
| 1269 | SCOPED_TRACE(::testing::Message() << "sample_rate_hz=" << sample_rate_hz); |
| 1270 | RunManualVolumeChangeIsPossibleTest(sample_rate_hz); |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1271 | } |
| 1272 | } |
| 1273 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1274 | TEST_F(ApmTest, HighPassFilter) { |
andrew@webrtc.org | 648af74 | 2012-02-08 01:57:29 | [diff] [blame] | 1275 | // Turn HP filter on/off |
peah | 8271d04 | 2016-11-22 15:24:52 | [diff] [blame] | 1276 | AudioProcessing::Config apm_config; |
| 1277 | apm_config.high_pass_filter.enabled = true; |
| 1278 | apm_->ApplyConfig(apm_config); |
| 1279 | apm_config.high_pass_filter.enabled = false; |
| 1280 | apm_->ApplyConfig(apm_config); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 1281 | } |
| 1282 | |
andrew@webrtc.org | ecac9b7 | 2012-05-02 00:04:10 | [diff] [blame] | 1283 | TEST_F(ApmTest, AllProcessingDisabledByDefault) { |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 1284 | AudioProcessing::Config config = apm_->GetConfig(); |
| 1285 | EXPECT_FALSE(config.echo_canceller.enabled); |
| 1286 | EXPECT_FALSE(config.high_pass_filter.enabled); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1287 | EXPECT_FALSE(config.gain_controller1.enabled); |
saza | 0bad15f | 2019-10-16 09:46:11 | [diff] [blame] | 1288 | EXPECT_FALSE(config.noise_suppression.enabled); |
andrew@webrtc.org | ecac9b7 | 2012-05-02 00:04:10 | [diff] [blame] | 1289 | } |
| 1290 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1291 | TEST_F(ApmTest, NoProcessingWhenAllComponentsDisabledInt) { |
| 1292 | // Test that ProcessStream simply copies input to output when all components |
| 1293 | // are disabled. |
| 1294 | // Runs over all processing rates, and some particularly common or special |
| 1295 | // rates. |
| 1296 | // - 8000 Hz: lowest sample rate seen in Chrome metrics, |
| 1297 | // - 22050 Hz: APM input/output frames are not exactly 10 ms, |
| 1298 | // - 44100 Hz: very common desktop sample rate. |
| 1299 | constexpr int kSampleRatesHz[] = {8000, 16000, 22050, 32000, 44100, 48000}; |
| 1300 | for (size_t sample_rate_hz : kSampleRatesHz) { |
| 1301 | SCOPED_TRACE(::testing::Message() << "sample_rate_hz=" << sample_rate_hz); |
| 1302 | Init(sample_rate_hz, sample_rate_hz, sample_rate_hz, 2, 2, 2, false); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1303 | SetFrameTo(&frame_, 1000, 2000); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1304 | Int16FrameData frame_copy; |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1305 | frame_copy.CopyFrom(frame_); |
andrew@webrtc.org | ecac9b7 | 2012-05-02 00:04:10 | [diff] [blame] | 1306 | for (int j = 0; j < 1000; j++) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1307 | EXPECT_EQ(apm_->kNoError, |
| 1308 | apm_->ProcessStream( |
| 1309 | frame_.data.data(), |
| 1310 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1311 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1312 | frame_.data.data())); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1313 | EXPECT_TRUE(FrameDataAreEqual(frame_, frame_copy)); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1314 | EXPECT_EQ(apm_->kNoError, |
| 1315 | apm_->ProcessReverseStream( |
| 1316 | frame_.data.data(), |
| 1317 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1318 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1319 | frame_.data.data())); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1320 | EXPECT_TRUE(FrameDataAreEqual(frame_, frame_copy)); |
andrew@webrtc.org | ecac9b7 | 2012-05-02 00:04:10 | [diff] [blame] | 1321 | } |
| 1322 | } |
| 1323 | } |
| 1324 | |
mgraczyk@chromium.org | d6e84d9 | 2015-01-14 01:33:54 | [diff] [blame] | 1325 | TEST_F(ApmTest, NoProcessingWhenAllComponentsDisabledFloat) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1326 | // Test that ProcessStream simply copies input to output when all components |
| 1327 | // are disabled. |
Per Åhgren | c8626b6 | 2019-08-23 13:49:51 | [diff] [blame] | 1328 | const size_t kSamples = 160; |
| 1329 | const int sample_rate = 16000; |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1330 | const float src[kSamples] = {-1.0f, 0.0f, 1.0f}; |
mgraczyk@chromium.org | d6e84d9 | 2015-01-14 01:33:54 | [diff] [blame] | 1331 | float dest[kSamples] = {}; |
| 1332 | |
| 1333 | auto src_channels = &src[0]; |
| 1334 | auto dest_channels = &dest[0]; |
| 1335 | |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 1336 | apm_ = AudioProcessingBuilderForTesting().Create(); |
Gustaf Ullberg | cb30726 | 2019-10-29 08:30:44 | [diff] [blame] | 1337 | EXPECT_NOERR(apm_->ProcessStream(&src_channels, StreamConfig(sample_rate, 1), |
| 1338 | StreamConfig(sample_rate, 1), |
| 1339 | &dest_channels)); |
mgraczyk@chromium.org | d6e84d9 | 2015-01-14 01:33:54 | [diff] [blame] | 1340 | |
| 1341 | for (size_t i = 0; i < kSamples; ++i) { |
| 1342 | EXPECT_EQ(src[i], dest[i]); |
| 1343 | } |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 1344 | |
| 1345 | // Same for ProcessReverseStream. |
| 1346 | float rev_dest[kSamples] = {}; |
| 1347 | auto rev_dest_channels = &rev_dest[0]; |
| 1348 | |
| 1349 | StreamConfig input_stream = {sample_rate, 1}; |
| 1350 | StreamConfig output_stream = {sample_rate, 1}; |
| 1351 | EXPECT_NOERR(apm_->ProcessReverseStream(&src_channels, input_stream, |
| 1352 | output_stream, &rev_dest_channels)); |
| 1353 | |
| 1354 | for (size_t i = 0; i < kSamples; ++i) { |
| 1355 | EXPECT_EQ(src[i], rev_dest[i]); |
| 1356 | } |
mgraczyk@chromium.org | d6e84d9 | 2015-01-14 01:33:54 | [diff] [blame] | 1357 | } |
| 1358 | |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1359 | TEST_F(ApmTest, IdenticalInputChannelsResultInIdenticalOutputChannels) { |
| 1360 | EnableAllComponents(); |
| 1361 | |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 1362 | for (size_t i = 0; i < arraysize(kProcessSampleRates); i++) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1363 | Init(kProcessSampleRates[i], kProcessSampleRates[i], kProcessSampleRates[i], |
| 1364 | 2, 2, 2, false); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1365 | int analog_level = 127; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1366 | ASSERT_EQ(0, feof(far_file_)); |
| 1367 | ASSERT_EQ(0, feof(near_file_)); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1368 | while (ReadFrame(far_file_, &revframe_) && ReadFrame(near_file_, &frame_)) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1369 | CopyLeftToRightChannel(revframe_.data.data(), |
| 1370 | revframe_.samples_per_channel); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1371 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1372 | ASSERT_EQ( |
| 1373 | kNoErr, |
| 1374 | apm_->ProcessReverseStream( |
| 1375 | revframe_.data.data(), |
| 1376 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1377 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1378 | revframe_.data.data())); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1379 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1380 | CopyLeftToRightChannel(frame_.data.data(), frame_.samples_per_channel); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1381 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1382 | ASSERT_EQ(kNoErr, apm_->set_stream_delay_ms(0)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1383 | apm_->set_stream_analog_level(analog_level); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1384 | ASSERT_EQ(kNoErr, |
| 1385 | apm_->ProcessStream( |
| 1386 | frame_.data.data(), |
| 1387 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1388 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1389 | frame_.data.data())); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1390 | analog_level = apm_->recommended_stream_analog_level(); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1391 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1392 | VerifyChannelsAreEqual(frame_.data.data(), frame_.samples_per_channel); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1393 | } |
bjornv@webrtc.org | 3e10249 | 2013-02-14 15:29:09 | [diff] [blame] | 1394 | rewind(far_file_); |
| 1395 | rewind(near_file_); |
andrew@webrtc.org | 07bf9a0 | 2012-05-05 00:32:00 | [diff] [blame] | 1396 | } |
| 1397 | } |
| 1398 | |
bjornv@webrtc.org | cb0ea43 | 2014-06-09 08:21:52 | [diff] [blame] | 1399 | TEST_F(ApmTest, SplittingFilter) { |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1400 | // Verify the filter is not active through undistorted audio when: |
| 1401 | // 1. No components are enabled... |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1402 | SetFrameTo(&frame_, 1000); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1403 | Int16FrameData frame_copy; |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1404 | frame_copy.CopyFrom(frame_); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1405 | EXPECT_EQ(apm_->kNoError, |
| 1406 | apm_->ProcessStream( |
| 1407 | frame_.data.data(), |
| 1408 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1409 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1410 | frame_.data.data())); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1411 | EXPECT_EQ(apm_->kNoError, |
| 1412 | apm_->ProcessStream( |
| 1413 | frame_.data.data(), |
| 1414 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1415 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1416 | frame_.data.data())); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1417 | EXPECT_TRUE(FrameDataAreEqual(frame_, frame_copy)); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1418 | |
| 1419 | // 2. Only the level estimator is enabled... |
saza | 6787f23 | 2019-10-11 17:31:07 | [diff] [blame] | 1420 | auto apm_config = apm_->GetConfig(); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1421 | SetFrameTo(&frame_, 1000); |
| 1422 | frame_copy.CopyFrom(frame_); |
saza | 6787f23 | 2019-10-11 17:31:07 | [diff] [blame] | 1423 | apm_->ApplyConfig(apm_config); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1424 | EXPECT_EQ(apm_->kNoError, |
| 1425 | apm_->ProcessStream( |
| 1426 | frame_.data.data(), |
| 1427 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1428 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1429 | frame_.data.data())); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1430 | EXPECT_EQ(apm_->kNoError, |
| 1431 | apm_->ProcessStream( |
| 1432 | frame_.data.data(), |
| 1433 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1434 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1435 | frame_.data.data())); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1436 | EXPECT_TRUE(FrameDataAreEqual(frame_, frame_copy)); |
saza | 6787f23 | 2019-10-11 17:31:07 | [diff] [blame] | 1437 | apm_->ApplyConfig(apm_config); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1438 | |
Sam Zackrisson | cb1b556 | 2018-09-28 12:15:09 | [diff] [blame] | 1439 | // Check the test is valid. We should have distortion from the filter |
| 1440 | // when AEC is enabled (which won't affect the audio). |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 1441 | apm_config.echo_canceller.enabled = true; |
| 1442 | apm_config.echo_canceller.mobile_mode = false; |
| 1443 | apm_->ApplyConfig(apm_config); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1444 | frame_.samples_per_channel = 320; |
| 1445 | frame_.num_channels = 2; |
| 1446 | frame_.sample_rate_hz = 32000; |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1447 | SetFrameTo(&frame_, 1000); |
| 1448 | frame_copy.CopyFrom(frame_); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1449 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0)); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1450 | EXPECT_EQ(apm_->kNoError, |
| 1451 | apm_->ProcessStream( |
| 1452 | frame_.data.data(), |
| 1453 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1454 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1455 | frame_.data.data())); |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1456 | EXPECT_FALSE(FrameDataAreEqual(frame_, frame_copy)); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1457 | } |
| 1458 | |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1459 | #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 1460 | void ApmTest::ProcessDebugDump(absl::string_view in_filename, |
| 1461 | absl::string_view out_filename, |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1462 | Format format, |
| 1463 | int max_size_bytes) { |
Danil Chapovalov | 07122bc | 2019-03-26 13:37:01 | [diff] [blame] | 1464 | TaskQueueForTest worker_queue("ApmTest_worker_queue"); |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 1465 | FILE* in_file = fopen(std::string(in_filename).c_str(), "rb"); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1466 | ASSERT_TRUE(in_file != NULL); |
| 1467 | audioproc::Event event_msg; |
| 1468 | bool first_init = true; |
| 1469 | |
| 1470 | while (ReadMessageFromFile(in_file, &event_msg)) { |
| 1471 | if (event_msg.type() == audioproc::Event::INIT) { |
| 1472 | const audioproc::Init msg = event_msg.init(); |
| 1473 | int reverse_sample_rate = msg.sample_rate(); |
| 1474 | if (msg.has_reverse_sample_rate()) { |
| 1475 | reverse_sample_rate = msg.reverse_sample_rate(); |
| 1476 | } |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1477 | int output_sample_rate = msg.sample_rate(); |
| 1478 | if (msg.has_output_sample_rate()) { |
| 1479 | output_sample_rate = msg.output_sample_rate(); |
| 1480 | } |
| 1481 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1482 | Init(msg.sample_rate(), output_sample_rate, reverse_sample_rate, |
| 1483 | msg.num_input_channels(), msg.num_output_channels(), |
| 1484 | msg.num_reverse_channels(), false); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1485 | if (first_init) { |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1486 | // AttachAecDump() writes an additional init message. Don't start |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1487 | // recording until after the first init to avoid the extra message. |
Danil Chapovalov | b64eef1 | 2024-01-04 13:45:23 | [diff] [blame] | 1488 | auto aec_dump = AecDumpFactory::Create(out_filename, max_size_bytes, |
| 1489 | worker_queue.Get()); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1490 | EXPECT_TRUE(aec_dump); |
| 1491 | apm_->AttachAecDump(std::move(aec_dump)); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1492 | first_init = false; |
| 1493 | } |
| 1494 | |
| 1495 | } else if (event_msg.type() == audioproc::Event::REVERSE_STREAM) { |
| 1496 | const audioproc::ReverseStream msg = event_msg.reverse_stream(); |
| 1497 | |
| 1498 | if (msg.channel_size() > 0) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1499 | ASSERT_EQ(revframe_.num_channels, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1500 | static_cast<size_t>(msg.channel_size())); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1501 | for (int i = 0; i < msg.channel_size(); ++i) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1502 | memcpy(revfloat_cb_->channels()[i], msg.channel(i).data(), |
| 1503 | msg.channel(i).size()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1504 | } |
| 1505 | } else { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1506 | memcpy(revframe_.data.data(), msg.data().data(), msg.data().size()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1507 | if (format == kFloatFormat) { |
| 1508 | // We're using an int16 input file; convert to float. |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1509 | ConvertToFloat(revframe_, revfloat_cb_.get()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1510 | } |
| 1511 | } |
| 1512 | AnalyzeReverseStreamChooser(format); |
| 1513 | |
| 1514 | } else if (event_msg.type() == audioproc::Event::STREAM) { |
| 1515 | const audioproc::Stream msg = event_msg.stream(); |
| 1516 | // ProcessStream could have changed this for the output frame. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1517 | frame_.num_channels = apm_->num_input_channels(); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1518 | |
Alessio Bazzica | 3153b36 | 2022-09-05 14:05:24 | [diff] [blame] | 1519 | apm_->set_stream_analog_level(msg.applied_input_volume()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1520 | EXPECT_NOERR(apm_->set_stream_delay_ms(msg.delay())); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1521 | if (msg.has_keypress()) { |
| 1522 | apm_->set_stream_key_pressed(msg.keypress()); |
| 1523 | } else { |
| 1524 | apm_->set_stream_key_pressed(true); |
| 1525 | } |
| 1526 | |
| 1527 | if (msg.input_channel_size() > 0) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1528 | ASSERT_EQ(frame_.num_channels, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1529 | static_cast<size_t>(msg.input_channel_size())); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1530 | for (int i = 0; i < msg.input_channel_size(); ++i) { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1531 | memcpy(float_cb_->channels()[i], msg.input_channel(i).data(), |
| 1532 | msg.input_channel(i).size()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1533 | } |
| 1534 | } else { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1535 | memcpy(frame_.data.data(), msg.input_data().data(), |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 1536 | msg.input_data().size()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1537 | if (format == kFloatFormat) { |
| 1538 | // We're using an int16 input file; convert to float. |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1539 | ConvertToFloat(frame_, float_cb_.get()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1540 | } |
| 1541 | } |
| 1542 | ProcessStreamChooser(format); |
| 1543 | } |
| 1544 | } |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1545 | apm_->DetachAecDump(); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1546 | fclose(in_file); |
| 1547 | } |
| 1548 | |
| 1549 | void ApmTest::VerifyDebugDumpTest(Format format) { |
Minyue Li | 656d609 | 2018-08-10 13:38:52 | [diff] [blame] | 1550 | rtc::ScopedFakeClock fake_clock; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1551 | const std::string in_filename = test::ResourcePath("ref03", "aecdump"); |
henrik.lundin@webrtc.org | 1092ea0 | 2014-04-02 07:46:49 | [diff] [blame] | 1552 | std::string format_string; |
| 1553 | switch (format) { |
| 1554 | case kIntFormat: |
| 1555 | format_string = "_int"; |
| 1556 | break; |
| 1557 | case kFloatFormat: |
| 1558 | format_string = "_float"; |
| 1559 | break; |
| 1560 | } |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 1561 | const std::string ref_filename = test::TempFilename( |
| 1562 | test::OutputPath(), std::string("ref") + format_string + "_aecdump"); |
| 1563 | const std::string out_filename = test::TempFilename( |
| 1564 | test::OutputPath(), std::string("out") + format_string + "_aecdump"); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1565 | const std::string limited_filename = test::TempFilename( |
| 1566 | test::OutputPath(), std::string("limited") + format_string + "_aecdump"); |
| 1567 | const size_t logging_limit_bytes = 100000; |
| 1568 | // We expect at least this many bytes in the created logfile. |
| 1569 | const size_t logging_expected_bytes = 95000; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1570 | EnableAllComponents(); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1571 | ProcessDebugDump(in_filename, ref_filename, format, -1); |
| 1572 | ProcessDebugDump(ref_filename, out_filename, format, -1); |
| 1573 | ProcessDebugDump(ref_filename, limited_filename, format, logging_limit_bytes); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1574 | |
| 1575 | FILE* ref_file = fopen(ref_filename.c_str(), "rb"); |
| 1576 | FILE* out_file = fopen(out_filename.c_str(), "rb"); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1577 | FILE* limited_file = fopen(limited_filename.c_str(), "rb"); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1578 | ASSERT_TRUE(ref_file != NULL); |
| 1579 | ASSERT_TRUE(out_file != NULL); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1580 | ASSERT_TRUE(limited_file != NULL); |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 1581 | std::unique_ptr<uint8_t[]> ref_bytes; |
| 1582 | std::unique_ptr<uint8_t[]> out_bytes; |
| 1583 | std::unique_ptr<uint8_t[]> limited_bytes; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1584 | |
| 1585 | size_t ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes); |
| 1586 | size_t out_size = ReadMessageBytesFromFile(out_file, &out_bytes); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1587 | size_t limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1588 | size_t bytes_read = 0; |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1589 | size_t bytes_read_limited = 0; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1590 | while (ref_size > 0 && out_size > 0) { |
| 1591 | bytes_read += ref_size; |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1592 | bytes_read_limited += limited_size; |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1593 | EXPECT_EQ(ref_size, out_size); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1594 | EXPECT_GE(ref_size, limited_size); |
Alessio Bazzica | 85a126e | 2022-08-11 13:48:54 | [diff] [blame] | 1595 | EXPECT_TRUE(ExpectMessageEq(/*actual=*/{out_bytes.get(), out_size}, |
| 1596 | /*expected=*/{ref_bytes.get(), ref_size})); |
| 1597 | if (limited_size > 0) { |
| 1598 | EXPECT_TRUE( |
| 1599 | ExpectMessageEq(/*actual=*/{limited_bytes.get(), limited_size}, |
| 1600 | /*expected=*/{ref_bytes.get(), ref_size})); |
| 1601 | } |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1602 | ref_size = ReadMessageBytesFromFile(ref_file, &ref_bytes); |
| 1603 | out_size = ReadMessageBytesFromFile(out_file, &out_bytes); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1604 | limited_size = ReadMessageBytesFromFile(limited_file, &limited_bytes); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1605 | } |
| 1606 | EXPECT_GT(bytes_read, 0u); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1607 | EXPECT_GT(bytes_read_limited, logging_expected_bytes); |
| 1608 | EXPECT_LE(bytes_read_limited, logging_limit_bytes); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1609 | EXPECT_NE(0, feof(ref_file)); |
| 1610 | EXPECT_NE(0, feof(out_file)); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1611 | EXPECT_NE(0, feof(limited_file)); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1612 | ASSERT_EQ(0, fclose(ref_file)); |
| 1613 | ASSERT_EQ(0, fclose(out_file)); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1614 | ASSERT_EQ(0, fclose(limited_file)); |
Peter Boström | fade179 | 2015-05-12 08:44:11 | [diff] [blame] | 1615 | remove(ref_filename.c_str()); |
| 1616 | remove(out_filename.c_str()); |
ivoc | d66b44d | 2016-01-15 11:06:36 | [diff] [blame] | 1617 | remove(limited_filename.c_str()); |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1618 | } |
| 1619 | |
pbos | c7a6569 | 2016-05-06 19:50:04 | [diff] [blame] | 1620 | TEST_F(ApmTest, VerifyDebugDumpInt) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1621 | VerifyDebugDumpTest(kIntFormat); |
| 1622 | } |
| 1623 | |
pbos | c7a6569 | 2016-05-06 19:50:04 | [diff] [blame] | 1624 | TEST_F(ApmTest, VerifyDebugDumpFloat) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1625 | VerifyDebugDumpTest(kFloatFormat); |
| 1626 | } |
| 1627 | #endif |
| 1628 | |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1629 | // TODO(andrew): expand test to verify output. |
pbos | c7a6569 | 2016-05-06 19:50:04 | [diff] [blame] | 1630 | TEST_F(ApmTest, DebugDump) { |
Danil Chapovalov | 07122bc | 2019-03-26 13:37:01 | [diff] [blame] | 1631 | TaskQueueForTest worker_queue("ApmTest_worker_queue"); |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 1632 | const std::string filename = |
| 1633 | test::TempFilename(test::OutputPath(), "debug_aec"); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1634 | { |
Danil Chapovalov | b64eef1 | 2024-01-04 13:45:23 | [diff] [blame] | 1635 | auto aec_dump = AecDumpFactory::Create("", -1, worker_queue.Get()); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1636 | EXPECT_FALSE(aec_dump); |
| 1637 | } |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1638 | |
| 1639 | #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP |
| 1640 | // Stopping without having started should be OK. |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1641 | apm_->DetachAecDump(); |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1642 | |
Danil Chapovalov | b64eef1 | 2024-01-04 13:45:23 | [diff] [blame] | 1643 | auto aec_dump = AecDumpFactory::Create(filename, -1, worker_queue.Get()); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1644 | EXPECT_TRUE(aec_dump); |
| 1645 | apm_->AttachAecDump(std::move(aec_dump)); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1646 | EXPECT_EQ(apm_->kNoError, |
| 1647 | apm_->ProcessStream( |
| 1648 | frame_.data.data(), |
| 1649 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1650 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1651 | frame_.data.data())); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1652 | EXPECT_EQ(apm_->kNoError, |
| 1653 | apm_->ProcessReverseStream( |
| 1654 | revframe_.data.data(), |
| 1655 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1656 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1657 | revframe_.data.data())); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1658 | apm_->DetachAecDump(); |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1659 | |
| 1660 | // Verify the file has been written. |
andrew@webrtc.org | f5d8c3b | 2012-01-24 21:35:39 | [diff] [blame] | 1661 | FILE* fid = fopen(filename.c_str(), "r"); |
| 1662 | ASSERT_TRUE(fid != NULL); |
| 1663 | |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1664 | // Clean it up. |
andrew@webrtc.org | f5d8c3b | 2012-01-24 21:35:39 | [diff] [blame] | 1665 | ASSERT_EQ(0, fclose(fid)); |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1666 | ASSERT_EQ(0, remove(filename.c_str())); |
| 1667 | #else |
andrew@webrtc.org | 7bf2646 | 2011-12-03 00:03:31 | [diff] [blame] | 1668 | // Verify the file has NOT been written. |
| 1669 | ASSERT_TRUE(fopen(filename.c_str(), "r") == NULL); |
| 1670 | #endif // WEBRTC_AUDIOPROC_DEBUG_DUMP |
| 1671 | } |
| 1672 | |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1673 | // TODO(andrew): expand test to verify output. |
pbos | c7a6569 | 2016-05-06 19:50:04 | [diff] [blame] | 1674 | TEST_F(ApmTest, DebugDumpFromFileHandle) { |
Danil Chapovalov | 07122bc | 2019-03-26 13:37:01 | [diff] [blame] | 1675 | TaskQueueForTest worker_queue("ApmTest_worker_queue"); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1676 | |
pbos@webrtc.org | a525c98 | 2015-01-12 17:31:18 | [diff] [blame] | 1677 | const std::string filename = |
| 1678 | test::TempFilename(test::OutputPath(), "debug_aec"); |
Ali Tofigh | 2ab914c | 2022-04-13 10:55:15 | [diff] [blame] | 1679 | FileWrapper f = FileWrapper::OpenWriteOnly(filename); |
Niels Möller | e8e4dc4 | 2019-06-11 12:04:16 | [diff] [blame] | 1680 | ASSERT_TRUE(f.is_open()); |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1681 | |
| 1682 | #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP |
| 1683 | // Stopping without having started should be OK. |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1684 | apm_->DetachAecDump(); |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1685 | |
Danil Chapovalov | b64eef1 | 2024-01-04 13:45:23 | [diff] [blame] | 1686 | auto aec_dump = AecDumpFactory::Create(std::move(f), -1, worker_queue.Get()); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1687 | EXPECT_TRUE(aec_dump); |
| 1688 | apm_->AttachAecDump(std::move(aec_dump)); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1689 | EXPECT_EQ(apm_->kNoError, |
| 1690 | apm_->ProcessReverseStream( |
| 1691 | revframe_.data.data(), |
| 1692 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1693 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1694 | revframe_.data.data())); |
| 1695 | EXPECT_EQ(apm_->kNoError, |
| 1696 | apm_->ProcessStream( |
| 1697 | frame_.data.data(), |
| 1698 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1699 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1700 | frame_.data.data())); |
aleloi | f4dd191 | 2017-06-15 08:55:38 | [diff] [blame] | 1701 | apm_->DetachAecDump(); |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1702 | |
| 1703 | // Verify the file has been written. |
Niels Möller | e8e4dc4 | 2019-06-11 12:04:16 | [diff] [blame] | 1704 | FILE* fid = fopen(filename.c_str(), "r"); |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1705 | ASSERT_TRUE(fid != NULL); |
| 1706 | |
| 1707 | // Clean it up. |
| 1708 | ASSERT_EQ(0, fclose(fid)); |
| 1709 | ASSERT_EQ(0, remove(filename.c_str())); |
henrikg@webrtc.org | 863b536 | 2013-12-06 16:05:17 | [diff] [blame] | 1710 | #endif // WEBRTC_AUDIOPROC_DEBUG_DUMP |
| 1711 | } |
| 1712 | |
andrew@webrtc.org | 75f1948 | 2012-02-09 17:16:18 | [diff] [blame] | 1713 | // TODO(andrew): Add a test to process a few frames with different combinations |
| 1714 | // of enabled components. |
| 1715 | |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1716 | TEST_F(ApmTest, Process) { |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1717 | GOOGLE_PROTOBUF_VERIFY_VERSION; |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1718 | audioproc::OutputData ref_data; |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1719 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 1720 | if (!absl::GetFlag(FLAGS_write_apm_ref_data)) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1721 | OpenFileAndReadMessage(ref_filename_, &ref_data); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1722 | } else { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1723 | const int kChannels[] = {1, 2}; |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 1724 | // Write the desired tests to the protobuf reference file. |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 1725 | for (size_t i = 0; i < arraysize(kChannels); i++) { |
| 1726 | for (size_t j = 0; j < arraysize(kChannels); j++) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1727 | for (int sample_rate_hz : AudioProcessing::kNativeSampleRatesHz) { |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1728 | audioproc::Test* test = ref_data.add_test(); |
andrew@webrtc.org | 60730cf | 2014-01-07 17:45:09 | [diff] [blame] | 1729 | test->set_num_reverse_channels(kChannels[i]); |
| 1730 | test->set_num_input_channels(kChannels[j]); |
| 1731 | test->set_num_output_channels(kChannels[j]); |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1732 | test->set_sample_rate(sample_rate_hz); |
aluebs@webrtc.org | f17ee9c | 2015-01-29 00:03:53 | [diff] [blame] | 1733 | test->set_use_aec_extended_filter(false); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1734 | } |
| 1735 | } |
| 1736 | } |
aluebs@webrtc.org | f17ee9c | 2015-01-29 00:03:53 | [diff] [blame] | 1737 | #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
| 1738 | // To test the extended filter mode. |
| 1739 | audioproc::Test* test = ref_data.add_test(); |
| 1740 | test->set_num_reverse_channels(2); |
| 1741 | test->set_num_input_channels(2); |
| 1742 | test->set_num_output_channels(2); |
| 1743 | test->set_sample_rate(AudioProcessing::kSampleRate32kHz); |
| 1744 | test->set_use_aec_extended_filter(true); |
| 1745 | #endif |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1746 | } |
| 1747 | |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 1748 | for (int i = 0; i < ref_data.test_size(); i++) { |
| 1749 | printf("Running test %d of %d...\n", i + 1, ref_data.test_size()); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1750 | |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 1751 | audioproc::Test* test = ref_data.mutable_test(i); |
andrew@webrtc.org | 60730cf | 2014-01-07 17:45:09 | [diff] [blame] | 1752 | // TODO(ajm): We no longer allow different input and output channels. Skip |
| 1753 | // these tests for now, but they should be removed from the set. |
| 1754 | if (test->num_input_channels() != test->num_output_channels()) |
| 1755 | continue; |
| 1756 | |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 1757 | apm_ = AudioProcessingBuilderForTesting() |
| 1758 | .SetEchoDetector(CreateEchoDetector()) |
| 1759 | .Create(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1760 | AudioProcessing::Config apm_config = apm_->GetConfig(); |
| 1761 | apm_config.gain_controller1.analog_gain_controller.enabled = false; |
| 1762 | apm_->ApplyConfig(apm_config); |
aluebs@webrtc.org | f17ee9c | 2015-01-29 00:03:53 | [diff] [blame] | 1763 | |
| 1764 | EnableAllComponents(); |
| 1765 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1766 | Init(test->sample_rate(), test->sample_rate(), test->sample_rate(), |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1767 | static_cast<size_t>(test->num_input_channels()), |
| 1768 | static_cast<size_t>(test->num_output_channels()), |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1769 | static_cast<size_t>(test->num_reverse_channels()), true); |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 1770 | |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1771 | int frame_count = 0; |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1772 | int analog_level = 127; |
| 1773 | int analog_level_average = 0; |
| 1774 | int max_output_average = 0; |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1775 | #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1776 | int stats_index = 0; |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1777 | #endif |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1778 | |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1779 | while (ReadFrame(far_file_, &revframe_) && ReadFrame(near_file_, &frame_)) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1780 | EXPECT_EQ( |
| 1781 | apm_->kNoError, |
| 1782 | apm_->ProcessReverseStream( |
| 1783 | revframe_.data.data(), |
| 1784 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1785 | StreamConfig(revframe_.sample_rate_hz, revframe_.num_channels), |
| 1786 | revframe_.data.data())); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1787 | |
| 1788 | EXPECT_EQ(apm_->kNoError, apm_->set_stream_delay_ms(0)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1789 | apm_->set_stream_analog_level(analog_level); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1790 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1791 | EXPECT_EQ(apm_->kNoError, |
| 1792 | apm_->ProcessStream( |
| 1793 | frame_.data.data(), |
| 1794 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
| 1795 | StreamConfig(frame_.sample_rate_hz, frame_.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 1796 | frame_.data.data())); |
andrew@webrtc.org | 17e4064 | 2014-03-04 20:58:13 | [diff] [blame] | 1797 | |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 1798 | // Ensure the frame was downmixed properly. |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1799 | EXPECT_EQ(static_cast<size_t>(test->num_output_channels()), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1800 | frame_.num_channels); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1801 | |
Sam Zackrisson | 70770ac | 2019-10-25 08:56:53 | [diff] [blame] | 1802 | max_output_average += MaxAudioFrame(frame_); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1803 | |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 1804 | analog_level = apm_->recommended_stream_analog_level(); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1805 | analog_level_average += analog_level; |
Per Åhgren | cf4c872 | 2019-12-30 13:32:14 | [diff] [blame] | 1806 | AudioProcessingStats stats = apm_->GetStatistics(); |
bjornv@webrtc.org | 08329f4 | 2012-07-12 21:00:43 | [diff] [blame] | 1807 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1808 | size_t frame_size = frame_.samples_per_channel * frame_.num_channels; |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 1809 | size_t write_count = |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1810 | fwrite(frame_.data.data(), sizeof(int16_t), frame_size, out_file_); |
andrew@webrtc.org | daacee8 | 2012-02-07 00:01:04 | [diff] [blame] | 1811 | ASSERT_EQ(frame_size, write_count); |
| 1812 | |
| 1813 | // Reset in case of downmixing. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 1814 | frame_.num_channels = static_cast<size_t>(test->num_input_channels()); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1815 | frame_count++; |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1816 | |
| 1817 | #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
| 1818 | const int kStatsAggregationFrameNum = 100; // 1 second. |
| 1819 | if (frame_count % kStatsAggregationFrameNum == 0) { |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1820 | // Get echo and delay metrics. |
Mirko Bonadei | 54c90f2 | 2021-10-03 09:26:11 | [diff] [blame] | 1821 | AudioProcessingStats stats2 = apm_->GetStatistics(); |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1822 | |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1823 | // Echo metrics. |
Mirko Bonadei | 54c90f2 | 2021-10-03 09:26:11 | [diff] [blame] | 1824 | const float echo_return_loss = stats2.echo_return_loss.value_or(-1.0f); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1825 | const float echo_return_loss_enhancement = |
Mirko Bonadei | 54c90f2 | 2021-10-03 09:26:11 | [diff] [blame] | 1826 | stats2.echo_return_loss_enhancement.value_or(-1.0f); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1827 | const float residual_echo_likelihood = |
Mirko Bonadei | 54c90f2 | 2021-10-03 09:26:11 | [diff] [blame] | 1828 | stats2.residual_echo_likelihood.value_or(-1.0f); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1829 | const float residual_echo_likelihood_recent_max = |
Mirko Bonadei | 54c90f2 | 2021-10-03 09:26:11 | [diff] [blame] | 1830 | stats2.residual_echo_likelihood_recent_max.value_or(-1.0f); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1831 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 1832 | if (!absl::GetFlag(FLAGS_write_apm_ref_data)) { |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1833 | const audioproc::Test::EchoMetrics& reference = |
| 1834 | test->echo_metrics(stats_index); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1835 | constexpr float kEpsilon = 0.01; |
| 1836 | EXPECT_NEAR(echo_return_loss, reference.echo_return_loss(), kEpsilon); |
| 1837 | EXPECT_NEAR(echo_return_loss_enhancement, |
| 1838 | reference.echo_return_loss_enhancement(), kEpsilon); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1839 | EXPECT_NEAR(residual_echo_likelihood, |
| 1840 | reference.residual_echo_likelihood(), kEpsilon); |
| 1841 | EXPECT_NEAR(residual_echo_likelihood_recent_max, |
| 1842 | reference.residual_echo_likelihood_recent_max(), |
| 1843 | kEpsilon); |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1844 | ++stats_index; |
| 1845 | } else { |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1846 | audioproc::Test::EchoMetrics* message_echo = test->add_echo_metrics(); |
| 1847 | message_echo->set_echo_return_loss(echo_return_loss); |
| 1848 | message_echo->set_echo_return_loss_enhancement( |
| 1849 | echo_return_loss_enhancement); |
Sam Zackrisson | af6c139 | 2018-09-13 10:59:09 | [diff] [blame] | 1850 | message_echo->set_residual_echo_likelihood(residual_echo_likelihood); |
| 1851 | message_echo->set_residual_echo_likelihood_recent_max( |
| 1852 | residual_echo_likelihood_recent_max); |
minyue | 58530ed | 2016-05-24 12:50:12 | [diff] [blame] | 1853 | } |
| 1854 | } |
| 1855 | #endif // defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE). |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1856 | } |
| 1857 | max_output_average /= frame_count; |
| 1858 | analog_level_average /= frame_count; |
| 1859 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 1860 | if (!absl::GetFlag(FLAGS_write_apm_ref_data)) { |
bjornv@webrtc.org | 8dd60cc | 2014-09-11 08:36:35 | [diff] [blame] | 1861 | const int kIntNear = 1; |
Alessio Bazzica | 1db0a26 | 2022-02-15 14:18:09 | [diff] [blame] | 1862 | // All numbers being consistently higher on N7 compare to the reference |
| 1863 | // data. |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1864 | // TODO(bjornv): If we start getting more of these offsets on Android we |
| 1865 | // should consider a different approach. Either using one slack for all, |
| 1866 | // or generate a separate android reference. |
Kári Tristan Helgason | 640106e | 2018-09-06 13:29:45 | [diff] [blame] | 1867 | #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1868 | const int kMaxOutputAverageOffset = 9; |
Sam Zackrisson | e507b0c | 2018-07-20 13:22:50 | [diff] [blame] | 1869 | const int kMaxOutputAverageNear = 26; |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1870 | #else |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1871 | const int kMaxOutputAverageOffset = 0; |
| 1872 | const int kMaxOutputAverageNear = kIntNear; |
| 1873 | #endif |
bjornv@webrtc.org | 8dd60cc | 2014-09-11 08:36:35 | [diff] [blame] | 1874 | EXPECT_NEAR(test->analog_level_average(), analog_level_average, kIntNear); |
bjornv@webrtc.org | dc0b37d | 2014-09-23 05:03:44 | [diff] [blame] | 1875 | EXPECT_NEAR(test->max_output_average(), |
| 1876 | max_output_average - kMaxOutputAverageOffset, |
| 1877 | kMaxOutputAverageNear); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1878 | } else { |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1879 | test->set_analog_level_average(analog_level_average); |
| 1880 | test->set_max_output_average(max_output_average); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1881 | } |
| 1882 | |
| 1883 | rewind(far_file_); |
| 1884 | rewind(near_file_); |
| 1885 | } |
| 1886 | |
Sam Zackrisson | 6558fa5 | 2019-08-26 08:12:41 | [diff] [blame] | 1887 | if (absl::GetFlag(FLAGS_write_apm_ref_data)) { |
andrew@webrtc.org | a8b9737 | 2014-03-10 22:26:12 | [diff] [blame] | 1888 | OpenFileAndWriteMessage(ref_filename_, ref_data); |
andrew@webrtc.org | 755b04a | 2011-11-15 16:57:56 | [diff] [blame] | 1889 | } |
| 1890 | } |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1891 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1892 | // Compares the reference and test arrays over a region around the expected |
| 1893 | // delay. Finds the highest SNR in that region and adds the variance and squared |
| 1894 | // error results to the supplied accumulators. |
| 1895 | void UpdateBestSNR(const float* ref, |
| 1896 | const float* test, |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 1897 | size_t length, |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1898 | int expected_delay, |
| 1899 | double* variance_acc, |
| 1900 | double* sq_error_acc) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1901 | RTC_CHECK_LT(expected_delay, length) |
| 1902 | << "delay greater than signal length, cannot compute SNR"; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1903 | double best_snr = std::numeric_limits<double>::min(); |
| 1904 | double best_variance = 0; |
| 1905 | double best_sq_error = 0; |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1906 | // Search over a region of nine samples around the expected delay. |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1907 | for (int delay = std::max(expected_delay - 4, 0); delay <= expected_delay + 4; |
| 1908 | ++delay) { |
| 1909 | double sq_error = 0; |
| 1910 | double variance = 0; |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 1911 | for (size_t i = 0; i < length - delay; ++i) { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1912 | double error = test[i + delay] - ref[i]; |
| 1913 | sq_error += error * error; |
| 1914 | variance += ref[i] * ref[i]; |
| 1915 | } |
| 1916 | |
| 1917 | if (sq_error == 0) { |
| 1918 | *variance_acc += variance; |
| 1919 | return; |
| 1920 | } |
| 1921 | double snr = variance / sq_error; |
| 1922 | if (snr > best_snr) { |
| 1923 | best_snr = snr; |
| 1924 | best_variance = variance; |
| 1925 | best_sq_error = sq_error; |
| 1926 | } |
| 1927 | } |
| 1928 | |
| 1929 | *variance_acc += best_variance; |
| 1930 | *sq_error_acc += best_sq_error; |
| 1931 | } |
| 1932 | |
| 1933 | // Used to test a multitude of sample rate and channel combinations. It works |
| 1934 | // by first producing a set of reference files (in SetUpTestCase) that are |
| 1935 | // assumed to be correct, as the used parameters are verified by other tests |
| 1936 | // in this collection. Primarily the reference files are all produced at |
| 1937 | // "native" rates which do not involve any resampling. |
| 1938 | |
| 1939 | // Each test pass produces an output file with a particular format. The output |
| 1940 | // is matched against the reference file closest to its internal processing |
| 1941 | // format. If necessary the output is resampled back to its process format. |
| 1942 | // Due to the resampling distortion, we don't expect identical results, but |
| 1943 | // enforce SNR thresholds which vary depending on the format. 0 is a special |
| 1944 | // case SNR which corresponds to inf, or zero error. |
Edward Lemur | c5ee987 | 2017-10-23 21:33:04 | [diff] [blame] | 1945 | typedef std::tuple<int, int, int, int, double, double> AudioProcessingTestData; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1946 | class AudioProcessingTest |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 1947 | : public ::testing::TestWithParam<AudioProcessingTestData> { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1948 | public: |
| 1949 | AudioProcessingTest() |
Edward Lemur | c5ee987 | 2017-10-23 21:33:04 | [diff] [blame] | 1950 | : input_rate_(std::get<0>(GetParam())), |
| 1951 | output_rate_(std::get<1>(GetParam())), |
| 1952 | reverse_input_rate_(std::get<2>(GetParam())), |
| 1953 | reverse_output_rate_(std::get<3>(GetParam())), |
| 1954 | expected_snr_(std::get<4>(GetParam())), |
| 1955 | expected_reverse_snr_(std::get<5>(GetParam())) {} |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1956 | |
| 1957 | virtual ~AudioProcessingTest() {} |
| 1958 | |
Mirko Bonadei | 71061bc | 2019-06-04 07:01:51 | [diff] [blame] | 1959 | static void SetUpTestSuite() { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1960 | // Create all needed output reference files. |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1961 | const size_t kNumChannels[] = {1, 2}; |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1962 | for (size_t i = 0; i < arraysize(kProcessSampleRates); ++i) { |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 1963 | for (size_t j = 0; j < arraysize(kNumChannels); ++j) { |
| 1964 | for (size_t k = 0; k < arraysize(kNumChannels); ++k) { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1965 | // The reference files always have matching input and output channels. |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1966 | ProcessFormat(kProcessSampleRates[i], kProcessSampleRates[i], |
| 1967 | kProcessSampleRates[i], kProcessSampleRates[i], |
| 1968 | kNumChannels[j], kNumChannels[j], kNumChannels[k], |
| 1969 | kNumChannels[k], "ref"); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1970 | } |
| 1971 | } |
| 1972 | } |
| 1973 | } |
| 1974 | |
Gustaf Ullberg | 8ffeeb2 | 2017-10-11 09:42:38 | [diff] [blame] | 1975 | void TearDown() { |
| 1976 | // Remove "out" files after each test. |
| 1977 | ClearTempOutFiles(); |
| 1978 | } |
| 1979 | |
Mirko Bonadei | 71061bc | 2019-06-04 07:01:51 | [diff] [blame] | 1980 | static void TearDownTestSuite() { ClearTempFiles(); } |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 1981 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1982 | // Runs a process pass on files with the given parameters and dumps the output |
Artem Titov | 0b48930 | 2021-07-28 18:50:03 | [diff] [blame] | 1983 | // to a file specified with `output_file_prefix`. Both forward and reverse |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 1984 | // output streams are dumped. |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1985 | static void ProcessFormat(int input_rate, |
| 1986 | int output_rate, |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 1987 | int reverse_input_rate, |
| 1988 | int reverse_output_rate, |
Peter Kasting | 6955870 | 2016-01-13 00:26:35 | [diff] [blame] | 1989 | size_t num_input_channels, |
| 1990 | size_t num_output_channels, |
| 1991 | size_t num_reverse_input_channels, |
| 1992 | size_t num_reverse_output_channels, |
Ali Tofigh | f3592cb | 2022-08-16 12:44:38 | [diff] [blame] | 1993 | absl::string_view output_file_prefix) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1994 | AudioProcessing::Config apm_config; |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1995 | apm_config.gain_controller1.analog_gain_controller.enabled = false; |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 1996 | rtc::scoped_refptr<AudioProcessing> ap = |
| 1997 | AudioProcessingBuilderForTesting().SetConfig(apm_config).Create(); |
Per Åhgren | 0695df1 | 2020-01-13 13:43:13 | [diff] [blame] | 1998 | |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 1999 | EnableAllAPComponents(ap.get()); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2000 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2001 | ProcessingConfig processing_config = { |
| 2002 | {{input_rate, num_input_channels}, |
| 2003 | {output_rate, num_output_channels}, |
| 2004 | {reverse_input_rate, num_reverse_input_channels}, |
| 2005 | {reverse_output_rate, num_reverse_output_channels}}}; |
| 2006 | ap->Initialize(processing_config); |
| 2007 | |
| 2008 | FILE* far_file = |
| 2009 | fopen(ResourceFilePath("far", reverse_input_rate).c_str(), "rb"); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2010 | FILE* near_file = fopen(ResourceFilePath("near", input_rate).c_str(), "rb"); |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2011 | FILE* out_file = fopen( |
| 2012 | OutputFilePath( |
| 2013 | output_file_prefix, input_rate, output_rate, reverse_input_rate, |
| 2014 | reverse_output_rate, num_input_channels, num_output_channels, |
| 2015 | num_reverse_input_channels, num_reverse_output_channels, kForward) |
| 2016 | .c_str(), |
| 2017 | "wb"); |
| 2018 | FILE* rev_out_file = fopen( |
| 2019 | OutputFilePath( |
| 2020 | output_file_prefix, input_rate, output_rate, reverse_input_rate, |
| 2021 | reverse_output_rate, num_input_channels, num_output_channels, |
| 2022 | num_reverse_input_channels, num_reverse_output_channels, kReverse) |
| 2023 | .c_str(), |
| 2024 | "wb"); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2025 | ASSERT_TRUE(far_file != NULL); |
| 2026 | ASSERT_TRUE(near_file != NULL); |
| 2027 | ASSERT_TRUE(out_file != NULL); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2028 | ASSERT_TRUE(rev_out_file != NULL); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2029 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2030 | ChannelBuffer<float> fwd_cb(AudioProcessing::GetFrameSize(input_rate), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2031 | num_input_channels); |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2032 | ChannelBuffer<float> rev_cb( |
| 2033 | AudioProcessing::GetFrameSize(reverse_input_rate), |
| 2034 | num_reverse_input_channels); |
| 2035 | ChannelBuffer<float> out_cb(AudioProcessing::GetFrameSize(output_rate), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2036 | num_output_channels); |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2037 | ChannelBuffer<float> rev_out_cb( |
| 2038 | AudioProcessing::GetFrameSize(reverse_output_rate), |
| 2039 | num_reverse_output_channels); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2040 | |
| 2041 | // Temporary buffers. |
| 2042 | const int max_length = |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2043 | 2 * std::max(std::max(out_cb.num_frames(), rev_out_cb.num_frames()), |
| 2044 | std::max(fwd_cb.num_frames(), rev_cb.num_frames())); |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 2045 | std::unique_ptr<float[]> float_data(new float[max_length]); |
| 2046 | std::unique_ptr<int16_t[]> int_data(new int16_t[max_length]); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2047 | |
| 2048 | int analog_level = 127; |
| 2049 | while (ReadChunk(far_file, int_data.get(), float_data.get(), &rev_cb) && |
| 2050 | ReadChunk(near_file, int_data.get(), float_data.get(), &fwd_cb)) { |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2051 | EXPECT_NOERR(ap->ProcessReverseStream( |
| 2052 | rev_cb.channels(), processing_config.reverse_input_stream(), |
| 2053 | processing_config.reverse_output_stream(), rev_out_cb.channels())); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2054 | |
| 2055 | EXPECT_NOERR(ap->set_stream_delay_ms(0)); |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 2056 | ap->set_stream_analog_level(analog_level); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2057 | |
| 2058 | EXPECT_NOERR(ap->ProcessStream( |
Gustaf Ullberg | cb30726 | 2019-10-29 08:30:44 | [diff] [blame] | 2059 | fwd_cb.channels(), StreamConfig(input_rate, num_input_channels), |
| 2060 | StreamConfig(output_rate, num_output_channels), out_cb.channels())); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2061 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2062 | // Dump forward output to file. |
| 2063 | Interleave(out_cb.channels(), out_cb.num_frames(), out_cb.num_channels(), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2064 | float_data.get()); |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 2065 | size_t out_length = out_cb.num_channels() * out_cb.num_frames(); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2066 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2067 | ASSERT_EQ(out_length, fwrite(float_data.get(), sizeof(float_data[0]), |
| 2068 | out_length, out_file)); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2069 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2070 | // Dump reverse output to file. |
| 2071 | Interleave(rev_out_cb.channels(), rev_out_cb.num_frames(), |
| 2072 | rev_out_cb.num_channels(), float_data.get()); |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 2073 | size_t rev_out_length = |
| 2074 | rev_out_cb.num_channels() * rev_out_cb.num_frames(); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2075 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2076 | ASSERT_EQ(rev_out_length, fwrite(float_data.get(), sizeof(float_data[0]), |
| 2077 | rev_out_length, rev_out_file)); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2078 | |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 2079 | analog_level = ap->recommended_stream_analog_level(); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2080 | } |
| 2081 | fclose(far_file); |
| 2082 | fclose(near_file); |
| 2083 | fclose(out_file); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2084 | fclose(rev_out_file); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2085 | } |
| 2086 | |
| 2087 | protected: |
| 2088 | int input_rate_; |
| 2089 | int output_rate_; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2090 | int reverse_input_rate_; |
| 2091 | int reverse_output_rate_; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2092 | double expected_snr_; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2093 | double expected_reverse_snr_; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2094 | }; |
| 2095 | |
bjornv@webrtc.org | 2812b59 | 2014-06-02 11:27:29 | [diff] [blame] | 2096 | TEST_P(AudioProcessingTest, Formats) { |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2097 | struct ChannelFormat { |
| 2098 | int num_input; |
| 2099 | int num_output; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2100 | int num_reverse_input; |
| 2101 | int num_reverse_output; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2102 | }; |
| 2103 | ChannelFormat cf[] = { |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2104 | {1, 1, 1, 1}, {1, 1, 2, 1}, {2, 1, 1, 1}, |
| 2105 | {2, 1, 2, 1}, {2, 2, 1, 1}, {2, 2, 2, 2}, |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2106 | }; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2107 | |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 2108 | for (size_t i = 0; i < arraysize(cf); ++i) { |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2109 | ProcessFormat(input_rate_, output_rate_, reverse_input_rate_, |
| 2110 | reverse_output_rate_, cf[i].num_input, cf[i].num_output, |
| 2111 | cf[i].num_reverse_input, cf[i].num_reverse_output, "out"); |
Alejandro Luebs | 4774874 | 2015-05-22 19:00:21 | [diff] [blame] | 2112 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2113 | // Verify output for both directions. |
| 2114 | std::vector<StreamDirection> stream_directions; |
| 2115 | stream_directions.push_back(kForward); |
| 2116 | stream_directions.push_back(kReverse); |
| 2117 | for (StreamDirection file_direction : stream_directions) { |
| 2118 | const int in_rate = file_direction ? reverse_input_rate_ : input_rate_; |
| 2119 | const int out_rate = file_direction ? reverse_output_rate_ : output_rate_; |
| 2120 | const int out_num = |
| 2121 | file_direction ? cf[i].num_reverse_output : cf[i].num_output; |
| 2122 | const double expected_snr = |
| 2123 | file_direction ? expected_reverse_snr_ : expected_snr_; |
| 2124 | |
| 2125 | const int min_ref_rate = std::min(in_rate, out_rate); |
| 2126 | int ref_rate; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2127 | if (min_ref_rate > 32000) { |
| 2128 | ref_rate = 48000; |
| 2129 | } else if (min_ref_rate > 16000) { |
| 2130 | ref_rate = 32000; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2131 | } else { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2132 | ref_rate = 16000; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2133 | } |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 2134 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2135 | FILE* out_file = fopen( |
| 2136 | OutputFilePath("out", input_rate_, output_rate_, reverse_input_rate_, |
| 2137 | reverse_output_rate_, cf[i].num_input, |
| 2138 | cf[i].num_output, cf[i].num_reverse_input, |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2139 | cf[i].num_reverse_output, file_direction) |
| 2140 | .c_str(), |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2141 | "rb"); |
| 2142 | // The reference files always have matching input and output channels. |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 2143 | FILE* ref_file = |
| 2144 | fopen(OutputFilePath("ref", ref_rate, ref_rate, ref_rate, ref_rate, |
| 2145 | cf[i].num_output, cf[i].num_output, |
| 2146 | cf[i].num_reverse_output, |
| 2147 | cf[i].num_reverse_output, file_direction) |
| 2148 | .c_str(), |
| 2149 | "rb"); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2150 | ASSERT_TRUE(out_file != NULL); |
| 2151 | ASSERT_TRUE(ref_file != NULL); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2152 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2153 | const size_t ref_length = |
| 2154 | AudioProcessing::GetFrameSize(ref_rate) * out_num; |
| 2155 | const size_t out_length = |
| 2156 | AudioProcessing::GetFrameSize(out_rate) * out_num; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2157 | // Data from the reference file. |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 2158 | std::unique_ptr<float[]> ref_data(new float[ref_length]); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2159 | // Data from the output file. |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 2160 | std::unique_ptr<float[]> out_data(new float[out_length]); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2161 | // Data from the resampled output, in case the reference and output rates |
| 2162 | // don't match. |
kwiberg | 62eaacf | 2016-02-17 14:39:05 | [diff] [blame] | 2163 | std::unique_ptr<float[]> cmp_data(new float[ref_length]); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2164 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2165 | PushResampler<float> resampler; |
| 2166 | resampler.InitializeIfNeeded(out_rate, ref_rate, out_num); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2167 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2168 | // Compute the resampling delay of the output relative to the reference, |
| 2169 | // to find the region over which we should search for the best SNR. |
| 2170 | float expected_delay_sec = 0; |
| 2171 | if (in_rate != ref_rate) { |
| 2172 | // Input resampling delay. |
| 2173 | expected_delay_sec += |
| 2174 | PushSincResampler::AlgorithmicDelaySeconds(in_rate); |
| 2175 | } |
| 2176 | if (out_rate != ref_rate) { |
| 2177 | // Output resampling delay. |
| 2178 | expected_delay_sec += |
| 2179 | PushSincResampler::AlgorithmicDelaySeconds(ref_rate); |
| 2180 | // Delay of converting the output back to its processing rate for |
| 2181 | // testing. |
| 2182 | expected_delay_sec += |
| 2183 | PushSincResampler::AlgorithmicDelaySeconds(out_rate); |
| 2184 | } |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2185 | // The delay is multiplied by the number of channels because |
| 2186 | // UpdateBestSNR() computes the SNR over interleaved data without taking |
| 2187 | // channels into account. |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2188 | int expected_delay = |
Oleh Prypin | 708eccc | 2019-03-27 08:38:52 | [diff] [blame] | 2189 | std::floor(expected_delay_sec * ref_rate + 0.5f) * out_num; |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2190 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2191 | double variance = 0; |
| 2192 | double sq_error = 0; |
| 2193 | while (fread(out_data.get(), sizeof(out_data[0]), out_length, out_file) && |
| 2194 | fread(ref_data.get(), sizeof(ref_data[0]), ref_length, ref_file)) { |
| 2195 | float* out_ptr = out_data.get(); |
| 2196 | if (out_rate != ref_rate) { |
| 2197 | // Resample the output back to its internal processing rate if |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2198 | // necessary. |
pkasting | 25702cb | 2016-01-08 21:50:27 | [diff] [blame] | 2199 | ASSERT_EQ(ref_length, |
| 2200 | static_cast<size_t>(resampler.Resample( |
| 2201 | out_ptr, out_length, cmp_data.get(), ref_length))); |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2202 | out_ptr = cmp_data.get(); |
| 2203 | } |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2204 | |
Artem Titov | 0b48930 | 2021-07-28 18:50:03 | [diff] [blame] | 2205 | // Update the `sq_error` and `variance` accumulators with the highest |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2206 | // SNR of reference vs output. |
| 2207 | UpdateBestSNR(ref_data.get(), out_ptr, ref_length, expected_delay, |
| 2208 | &variance, &sq_error); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2209 | } |
| 2210 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2211 | std::cout << "(" << input_rate_ << ", " << output_rate_ << ", " |
| 2212 | << reverse_input_rate_ << ", " << reverse_output_rate_ << ", " |
| 2213 | << cf[i].num_input << ", " << cf[i].num_output << ", " |
| 2214 | << cf[i].num_reverse_input << ", " << cf[i].num_reverse_output |
| 2215 | << ", " << file_direction << "): "; |
| 2216 | if (sq_error > 0) { |
| 2217 | double snr = 10 * log10(variance / sq_error); |
| 2218 | EXPECT_GE(snr, expected_snr); |
| 2219 | EXPECT_NE(0, expected_snr); |
| 2220 | std::cout << "SNR=" << snr << " dB" << std::endl; |
| 2221 | } else { |
aluebs | 776593b | 2016-03-15 21:04:58 | [diff] [blame] | 2222 | std::cout << "SNR=inf dB" << std::endl; |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2223 | } |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2224 | |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2225 | fclose(out_file); |
| 2226 | fclose(ref_file); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2227 | } |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2228 | } |
| 2229 | } |
| 2230 | |
| 2231 | #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE) |
Mirko Bonadei | c84f661 | 2019-01-31 11:20:57 | [diff] [blame] | 2232 | INSTANTIATE_TEST_SUITE_P( |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2233 | CommonFormats, |
| 2234 | AudioProcessingTest, |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2235 | // Internal processing rates and the particularly common sample rate 44100 |
| 2236 | // Hz are tested in a grid of combinations (capture in, render in, out). |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2237 | ::testing::Values(std::make_tuple(48000, 48000, 48000, 48000, 0, 0), |
| 2238 | std::make_tuple(48000, 48000, 32000, 48000, 40, 30), |
| 2239 | std::make_tuple(48000, 48000, 16000, 48000, 40, 20), |
| 2240 | std::make_tuple(48000, 44100, 48000, 44100, 20, 20), |
| 2241 | std::make_tuple(48000, 44100, 32000, 44100, 20, 15), |
| 2242 | std::make_tuple(48000, 44100, 16000, 44100, 20, 15), |
| 2243 | std::make_tuple(48000, 32000, 48000, 32000, 30, 35), |
| 2244 | std::make_tuple(48000, 32000, 32000, 32000, 30, 0), |
| 2245 | std::make_tuple(48000, 32000, 16000, 32000, 30, 20), |
| 2246 | std::make_tuple(48000, 16000, 48000, 16000, 25, 20), |
| 2247 | std::make_tuple(48000, 16000, 32000, 16000, 25, 20), |
| 2248 | std::make_tuple(48000, 16000, 16000, 16000, 25, 0), |
Alejandro Luebs | 4774874 | 2015-05-22 19:00:21 | [diff] [blame] | 2249 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2250 | std::make_tuple(44100, 48000, 48000, 48000, 30, 0), |
| 2251 | std::make_tuple(44100, 48000, 32000, 48000, 30, 30), |
| 2252 | std::make_tuple(44100, 48000, 16000, 48000, 30, 20), |
| 2253 | std::make_tuple(44100, 44100, 48000, 44100, 20, 20), |
| 2254 | std::make_tuple(44100, 44100, 32000, 44100, 20, 15), |
| 2255 | std::make_tuple(44100, 44100, 16000, 44100, 20, 15), |
| 2256 | std::make_tuple(44100, 32000, 48000, 32000, 30, 35), |
| 2257 | std::make_tuple(44100, 32000, 32000, 32000, 30, 0), |
| 2258 | std::make_tuple(44100, 32000, 16000, 32000, 30, 20), |
| 2259 | std::make_tuple(44100, 16000, 48000, 16000, 25, 20), |
| 2260 | std::make_tuple(44100, 16000, 32000, 16000, 25, 20), |
| 2261 | std::make_tuple(44100, 16000, 16000, 16000, 25, 0), |
Alejandro Luebs | 4774874 | 2015-05-22 19:00:21 | [diff] [blame] | 2262 | |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 2263 | std::make_tuple(32000, 48000, 48000, 48000, 15, 0), |
| 2264 | std::make_tuple(32000, 48000, 32000, 48000, 15, 30), |
| 2265 | std::make_tuple(32000, 48000, 16000, 48000, 15, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2266 | std::make_tuple(32000, 44100, 48000, 44100, 19, 20), |
| 2267 | std::make_tuple(32000, 44100, 32000, 44100, 19, 15), |
| 2268 | std::make_tuple(32000, 44100, 16000, 44100, 19, 15), |
| 2269 | std::make_tuple(32000, 32000, 48000, 32000, 40, 35), |
| 2270 | std::make_tuple(32000, 32000, 32000, 32000, 0, 0), |
Gustaf Ullberg | 09226fc | 2021-02-19 12:03:14 | [diff] [blame] | 2271 | std::make_tuple(32000, 32000, 16000, 32000, 39, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2272 | std::make_tuple(32000, 16000, 48000, 16000, 25, 20), |
| 2273 | std::make_tuple(32000, 16000, 32000, 16000, 25, 20), |
| 2274 | std::make_tuple(32000, 16000, 16000, 16000, 25, 0), |
Alejandro Luebs | 4774874 | 2015-05-22 19:00:21 | [diff] [blame] | 2275 | |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 2276 | std::make_tuple(16000, 48000, 48000, 48000, 9, 0), |
| 2277 | std::make_tuple(16000, 48000, 32000, 48000, 9, 30), |
| 2278 | std::make_tuple(16000, 48000, 16000, 48000, 9, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2279 | std::make_tuple(16000, 44100, 48000, 44100, 15, 20), |
| 2280 | std::make_tuple(16000, 44100, 32000, 44100, 15, 15), |
| 2281 | std::make_tuple(16000, 44100, 16000, 44100, 15, 15), |
| 2282 | std::make_tuple(16000, 32000, 48000, 32000, 25, 35), |
| 2283 | std::make_tuple(16000, 32000, 32000, 32000, 25, 0), |
| 2284 | std::make_tuple(16000, 32000, 16000, 32000, 25, 20), |
| 2285 | std::make_tuple(16000, 16000, 48000, 16000, 39, 20), |
Gustaf Ullberg | 09226fc | 2021-02-19 12:03:14 | [diff] [blame] | 2286 | std::make_tuple(16000, 16000, 32000, 16000, 39, 20), |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2287 | std::make_tuple(16000, 16000, 16000, 16000, 0, 0), |
| 2288 | |
| 2289 | // Other sample rates are not tested exhaustively, to keep |
| 2290 | // the test runtime manageable. |
| 2291 | // |
| 2292 | // Testing most other sample rates logged by Chrome UMA: |
| 2293 | // - WebRTC.AudioInputSampleRate |
| 2294 | // - WebRTC.AudioOutputSampleRate |
| 2295 | // ApmConfiguration.HandlingOfRateCombinations covers |
| 2296 | // remaining sample rates. |
| 2297 | std::make_tuple(192000, 192000, 48000, 192000, 20, 40), |
| 2298 | std::make_tuple(176400, 176400, 48000, 176400, 20, 35), |
| 2299 | std::make_tuple(96000, 96000, 48000, 96000, 20, 40), |
| 2300 | std::make_tuple(88200, 88200, 48000, 88200, 20, 20), |
| 2301 | std::make_tuple(44100, 44100, 48000, 44100, 20, 20))); |
Alejandro Luebs | 4774874 | 2015-05-22 19:00:21 | [diff] [blame] | 2302 | |
| 2303 | #elif defined(WEBRTC_AUDIOPROC_FIXED_PROFILE) |
Mirko Bonadei | c84f661 | 2019-01-31 11:20:57 | [diff] [blame] | 2304 | INSTANTIATE_TEST_SUITE_P( |
ekmeyerson | 60d9b33 | 2015-08-14 17:35:55 | [diff] [blame] | 2305 | CommonFormats, |
| 2306 | AudioProcessingTest, |
Per Åhgren | 0aefbf0 | 2019-08-23 19:29:17 | [diff] [blame] | 2307 | ::testing::Values(std::make_tuple(48000, 48000, 48000, 48000, 19, 0), |
| 2308 | std::make_tuple(48000, 48000, 32000, 48000, 19, 30), |
| 2309 | std::make_tuple(48000, 48000, 16000, 48000, 19, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2310 | std::make_tuple(48000, 44100, 48000, 44100, 15, 20), |
| 2311 | std::make_tuple(48000, 44100, 32000, 44100, 15, 15), |
| 2312 | std::make_tuple(48000, 44100, 16000, 44100, 15, 15), |
Per Åhgren | 0aefbf0 | 2019-08-23 19:29:17 | [diff] [blame] | 2313 | std::make_tuple(48000, 32000, 48000, 32000, 19, 35), |
| 2314 | std::make_tuple(48000, 32000, 32000, 32000, 19, 0), |
| 2315 | std::make_tuple(48000, 32000, 16000, 32000, 19, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2316 | std::make_tuple(48000, 16000, 48000, 16000, 20, 20), |
| 2317 | std::make_tuple(48000, 16000, 32000, 16000, 20, 20), |
| 2318 | std::make_tuple(48000, 16000, 16000, 16000, 20, 0), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2319 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2320 | std::make_tuple(44100, 48000, 48000, 48000, 15, 0), |
| 2321 | std::make_tuple(44100, 48000, 32000, 48000, 15, 30), |
| 2322 | std::make_tuple(44100, 48000, 16000, 48000, 15, 20), |
| 2323 | std::make_tuple(44100, 44100, 48000, 44100, 15, 20), |
| 2324 | std::make_tuple(44100, 44100, 32000, 44100, 15, 15), |
| 2325 | std::make_tuple(44100, 44100, 16000, 44100, 15, 15), |
Per Åhgren | 0aefbf0 | 2019-08-23 19:29:17 | [diff] [blame] | 2326 | std::make_tuple(44100, 32000, 48000, 32000, 18, 35), |
| 2327 | std::make_tuple(44100, 32000, 32000, 32000, 18, 0), |
| 2328 | std::make_tuple(44100, 32000, 16000, 32000, 18, 20), |
| 2329 | std::make_tuple(44100, 16000, 48000, 16000, 19, 20), |
| 2330 | std::make_tuple(44100, 16000, 32000, 16000, 19, 20), |
| 2331 | std::make_tuple(44100, 16000, 16000, 16000, 19, 0), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2332 | |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 2333 | std::make_tuple(32000, 48000, 48000, 48000, 17, 0), |
| 2334 | std::make_tuple(32000, 48000, 32000, 48000, 17, 30), |
| 2335 | std::make_tuple(32000, 48000, 16000, 48000, 17, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2336 | std::make_tuple(32000, 44100, 48000, 44100, 20, 20), |
| 2337 | std::make_tuple(32000, 44100, 32000, 44100, 20, 15), |
| 2338 | std::make_tuple(32000, 44100, 16000, 44100, 20, 15), |
Per Åhgren | e35b32c | 2019-11-22 17:22:04 | [diff] [blame] | 2339 | std::make_tuple(32000, 32000, 48000, 32000, 27, 35), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2340 | std::make_tuple(32000, 32000, 32000, 32000, 0, 0), |
Per Åhgren | e35b32c | 2019-11-22 17:22:04 | [diff] [blame] | 2341 | std::make_tuple(32000, 32000, 16000, 32000, 30, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2342 | std::make_tuple(32000, 16000, 48000, 16000, 20, 20), |
| 2343 | std::make_tuple(32000, 16000, 32000, 16000, 20, 20), |
| 2344 | std::make_tuple(32000, 16000, 16000, 16000, 20, 0), |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2345 | |
Per Åhgren | c042425 | 2019-12-10 12:04:15 | [diff] [blame] | 2346 | std::make_tuple(16000, 48000, 48000, 48000, 11, 0), |
| 2347 | std::make_tuple(16000, 48000, 32000, 48000, 11, 30), |
| 2348 | std::make_tuple(16000, 48000, 16000, 48000, 11, 20), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2349 | std::make_tuple(16000, 44100, 48000, 44100, 15, 20), |
| 2350 | std::make_tuple(16000, 44100, 32000, 44100, 15, 15), |
| 2351 | std::make_tuple(16000, 44100, 16000, 44100, 15, 15), |
Per Åhgren | 0cbb58e | 2019-10-29 21:59:44 | [diff] [blame] | 2352 | std::make_tuple(16000, 32000, 48000, 32000, 24, 35), |
Per Åhgren | e35b32c | 2019-11-22 17:22:04 | [diff] [blame] | 2353 | std::make_tuple(16000, 32000, 32000, 32000, 24, 0), |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2354 | std::make_tuple(16000, 32000, 16000, 32000, 25, 20), |
Per Åhgren | e35b32c | 2019-11-22 17:22:04 | [diff] [blame] | 2355 | std::make_tuple(16000, 16000, 48000, 16000, 28, 20), |
| 2356 | std::make_tuple(16000, 16000, 32000, 16000, 28, 20), |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2357 | std::make_tuple(16000, 16000, 16000, 16000, 0, 0), |
| 2358 | |
| 2359 | std::make_tuple(192000, 192000, 48000, 192000, 20, 40), |
| 2360 | std::make_tuple(176400, 176400, 48000, 176400, 20, 35), |
| 2361 | std::make_tuple(96000, 96000, 48000, 96000, 20, 40), |
| 2362 | std::make_tuple(88200, 88200, 48000, 88200, 20, 20), |
| 2363 | std::make_tuple(44100, 44100, 48000, 44100, 20, 20))); |
andrew@webrtc.org | ddbb8a2 | 2014-04-22 21:00:04 | [diff] [blame] | 2364 | #endif |
| 2365 | |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2366 | // Produces a scoped trace debug output. |
| 2367 | std::string ProduceDebugText(int render_input_sample_rate_hz, |
| 2368 | int render_output_sample_rate_hz, |
| 2369 | int capture_input_sample_rate_hz, |
| 2370 | int capture_output_sample_rate_hz, |
| 2371 | size_t render_input_num_channels, |
| 2372 | size_t render_output_num_channels, |
| 2373 | size_t capture_input_num_channels, |
| 2374 | size_t capture_output_num_channels) { |
| 2375 | rtc::StringBuilder ss; |
| 2376 | ss << "Sample rates:" |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2377 | "\n Render input: " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 2378 | << render_input_sample_rate_hz |
| 2379 | << " Hz" |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2380 | "\n Render output: " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 2381 | << render_output_sample_rate_hz |
| 2382 | << " Hz" |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2383 | "\n Capture input: " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 2384 | << capture_input_sample_rate_hz |
| 2385 | << " Hz" |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2386 | "\n Capture output: " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 2387 | << capture_output_sample_rate_hz |
| 2388 | << " Hz" |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2389 | "\nNumber of channels:" |
| 2390 | "\n Render input: " |
Jonas Olsson | b2b2031 | 2020-01-14 11:11:31 | [diff] [blame] | 2391 | << render_input_num_channels |
Jonas Olsson | 6c9bc39 | 2020-01-14 14:54:35 | [diff] [blame] | 2392 | << "\n Render output: " << render_output_num_channels |
| 2393 | << "\n Capture input: " << capture_input_num_channels |
| 2394 | << "\n Capture output: " << capture_output_num_channels; |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2395 | return ss.Release(); |
| 2396 | } |
| 2397 | |
| 2398 | // Validates that running the audio processing module using various combinations |
| 2399 | // of sample rates and number of channels works as intended. |
| 2400 | void RunApmRateAndChannelTest( |
| 2401 | rtc::ArrayView<const int> sample_rates_hz, |
| 2402 | rtc::ArrayView<const int> render_channel_counts, |
| 2403 | rtc::ArrayView<const int> capture_channel_counts) { |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2404 | webrtc::AudioProcessing::Config apm_config; |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2405 | apm_config.pipeline.multi_channel_render = true; |
| 2406 | apm_config.pipeline.multi_channel_capture = true; |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2407 | apm_config.echo_canceller.enabled = true; |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2408 | rtc::scoped_refptr<AudioProcessing> apm = |
| 2409 | AudioProcessingBuilderForTesting().SetConfig(apm_config).Create(); |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2410 | |
| 2411 | StreamConfig render_input_stream_config; |
| 2412 | StreamConfig render_output_stream_config; |
| 2413 | StreamConfig capture_input_stream_config; |
| 2414 | StreamConfig capture_output_stream_config; |
| 2415 | |
| 2416 | std::vector<float> render_input_frame_channels; |
| 2417 | std::vector<float*> render_input_frame; |
| 2418 | std::vector<float> render_output_frame_channels; |
| 2419 | std::vector<float*> render_output_frame; |
| 2420 | std::vector<float> capture_input_frame_channels; |
| 2421 | std::vector<float*> capture_input_frame; |
| 2422 | std::vector<float> capture_output_frame_channels; |
| 2423 | std::vector<float*> capture_output_frame; |
| 2424 | |
| 2425 | for (auto render_input_sample_rate_hz : sample_rates_hz) { |
| 2426 | for (auto render_output_sample_rate_hz : sample_rates_hz) { |
| 2427 | for (auto capture_input_sample_rate_hz : sample_rates_hz) { |
| 2428 | for (auto capture_output_sample_rate_hz : sample_rates_hz) { |
| 2429 | for (size_t render_input_num_channels : render_channel_counts) { |
| 2430 | for (size_t capture_input_num_channels : capture_channel_counts) { |
| 2431 | size_t render_output_num_channels = render_input_num_channels; |
| 2432 | size_t capture_output_num_channels = capture_input_num_channels; |
| 2433 | auto populate_audio_frame = [](int sample_rate_hz, |
| 2434 | size_t num_channels, |
| 2435 | StreamConfig* cfg, |
| 2436 | std::vector<float>* channels_data, |
| 2437 | std::vector<float*>* frame_data) { |
| 2438 | cfg->set_sample_rate_hz(sample_rate_hz); |
| 2439 | cfg->set_num_channels(num_channels); |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2440 | |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2441 | size_t max_frame_size = |
| 2442 | AudioProcessing::GetFrameSize(sample_rate_hz); |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2443 | channels_data->resize(num_channels * max_frame_size); |
| 2444 | std::fill(channels_data->begin(), channels_data->end(), 0.5f); |
| 2445 | frame_data->resize(num_channels); |
| 2446 | for (size_t channel = 0; channel < num_channels; ++channel) { |
| 2447 | (*frame_data)[channel] = |
| 2448 | &(*channels_data)[channel * max_frame_size]; |
| 2449 | } |
| 2450 | }; |
| 2451 | |
| 2452 | populate_audio_frame( |
| 2453 | render_input_sample_rate_hz, render_input_num_channels, |
| 2454 | &render_input_stream_config, &render_input_frame_channels, |
| 2455 | &render_input_frame); |
| 2456 | populate_audio_frame( |
| 2457 | render_output_sample_rate_hz, render_output_num_channels, |
| 2458 | &render_output_stream_config, &render_output_frame_channels, |
| 2459 | &render_output_frame); |
| 2460 | populate_audio_frame( |
| 2461 | capture_input_sample_rate_hz, capture_input_num_channels, |
| 2462 | &capture_input_stream_config, &capture_input_frame_channels, |
| 2463 | &capture_input_frame); |
| 2464 | populate_audio_frame( |
| 2465 | capture_output_sample_rate_hz, capture_output_num_channels, |
| 2466 | &capture_output_stream_config, &capture_output_frame_channels, |
| 2467 | &capture_output_frame); |
| 2468 | |
| 2469 | for (size_t frame = 0; frame < 2; ++frame) { |
| 2470 | SCOPED_TRACE(ProduceDebugText( |
| 2471 | render_input_sample_rate_hz, render_output_sample_rate_hz, |
| 2472 | capture_input_sample_rate_hz, capture_output_sample_rate_hz, |
| 2473 | render_input_num_channels, render_output_num_channels, |
| 2474 | render_input_num_channels, capture_output_num_channels)); |
| 2475 | |
| 2476 | int result = apm->ProcessReverseStream( |
| 2477 | &render_input_frame[0], render_input_stream_config, |
| 2478 | render_output_stream_config, &render_output_frame[0]); |
| 2479 | EXPECT_EQ(result, AudioProcessing::kNoError); |
| 2480 | result = apm->ProcessStream( |
| 2481 | &capture_input_frame[0], capture_input_stream_config, |
| 2482 | capture_output_stream_config, &capture_output_frame[0]); |
| 2483 | EXPECT_EQ(result, AudioProcessing::kNoError); |
| 2484 | } |
| 2485 | } |
| 2486 | } |
| 2487 | } |
| 2488 | } |
| 2489 | } |
| 2490 | } |
| 2491 | } |
| 2492 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 2493 | constexpr void Toggle(bool& b) { |
| 2494 | b ^= true; |
| 2495 | } |
| 2496 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 | [diff] [blame] | 2497 | } // namespace |
peah | c19f312 | 2016-10-07 21:54:10 | [diff] [blame] | 2498 | |
Alessio Bazzica | c054e78 | 2018-04-16 10:10:09 | [diff] [blame] | 2499 | TEST(RuntimeSettingTest, TestDefaultCtor) { |
| 2500 | auto s = AudioProcessing::RuntimeSetting(); |
| 2501 | EXPECT_EQ(AudioProcessing::RuntimeSetting::Type::kNotSpecified, s.type()); |
| 2502 | } |
| 2503 | |
Alessio Bazzica | c054e78 | 2018-04-16 10:10:09 | [diff] [blame] | 2504 | TEST(RuntimeSettingTest, TestUsageWithSwapQueue) { |
| 2505 | SwapQueue<AudioProcessing::RuntimeSetting> q(1); |
| 2506 | auto s = AudioProcessing::RuntimeSetting(); |
| 2507 | ASSERT_TRUE(q.Insert(&s)); |
| 2508 | ASSERT_TRUE(q.Remove(&s)); |
| 2509 | EXPECT_EQ(AudioProcessing::RuntimeSetting::Type::kNotSpecified, s.type()); |
| 2510 | } |
| 2511 | |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2512 | TEST(ApmConfiguration, EnablePostProcessing) { |
| 2513 | // Verify that apm uses a capture post processing module if one is provided. |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2514 | auto mock_post_processor_ptr = |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2515 | new ::testing::NiceMock<test::MockCustomProcessing>(); |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2516 | auto mock_post_processor = |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2517 | std::unique_ptr<CustomProcessing>(mock_post_processor_ptr); |
Ivo Creusen | 5ec7e12 | 2017-12-22 10:35:59 | [diff] [blame] | 2518 | rtc::scoped_refptr<AudioProcessing> apm = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 2519 | AudioProcessingBuilderForTesting() |
Ivo Creusen | 5ec7e12 | 2017-12-22 10:35:59 | [diff] [blame] | 2520 | .SetCapturePostProcessing(std::move(mock_post_processor)) |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2521 | .Create(); |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2522 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2523 | Int16FrameData audio; |
| 2524 | audio.num_channels = 1; |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2525 | SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz); |
| 2526 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2527 | EXPECT_CALL(*mock_post_processor_ptr, Process(::testing::_)).Times(1); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2528 | apm->ProcessStream(audio.data.data(), |
| 2529 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2530 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2531 | audio.data.data()); |
Sam Zackrisson | 0beac58 | 2017-09-25 10:04:02 | [diff] [blame] | 2532 | } |
| 2533 | |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2534 | TEST(ApmConfiguration, EnablePreProcessing) { |
| 2535 | // Verify that apm uses a capture post processing module if one is provided. |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2536 | auto mock_pre_processor_ptr = |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2537 | new ::testing::NiceMock<test::MockCustomProcessing>(); |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2538 | auto mock_pre_processor = |
| 2539 | std::unique_ptr<CustomProcessing>(mock_pre_processor_ptr); |
Ivo Creusen | 62337e5 | 2018-01-09 13:17:33 | [diff] [blame] | 2540 | rtc::scoped_refptr<AudioProcessing> apm = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 2541 | AudioProcessingBuilderForTesting() |
Ivo Creusen | 62337e5 | 2018-01-09 13:17:33 | [diff] [blame] | 2542 | .SetRenderPreProcessing(std::move(mock_pre_processor)) |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2543 | .Create(); |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2544 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2545 | Int16FrameData audio; |
| 2546 | audio.num_channels = 1; |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2547 | SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz); |
| 2548 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2549 | EXPECT_CALL(*mock_pre_processor_ptr, Process(::testing::_)).Times(1); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2550 | apm->ProcessReverseStream( |
| 2551 | audio.data.data(), StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2552 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2553 | audio.data.data()); |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2554 | } |
| 2555 | |
Valeriia Nemychnikova | f06eb57 | 2018-08-29 08:37:09 | [diff] [blame] | 2556 | TEST(ApmConfiguration, EnableCaptureAnalyzer) { |
| 2557 | // Verify that apm uses a capture analyzer if one is provided. |
| 2558 | auto mock_capture_analyzer_ptr = |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2559 | new ::testing::NiceMock<test::MockCustomAudioAnalyzer>(); |
Valeriia Nemychnikova | f06eb57 | 2018-08-29 08:37:09 | [diff] [blame] | 2560 | auto mock_capture_analyzer = |
| 2561 | std::unique_ptr<CustomAudioAnalyzer>(mock_capture_analyzer_ptr); |
| 2562 | rtc::scoped_refptr<AudioProcessing> apm = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 2563 | AudioProcessingBuilderForTesting() |
Valeriia Nemychnikova | f06eb57 | 2018-08-29 08:37:09 | [diff] [blame] | 2564 | .SetCaptureAnalyzer(std::move(mock_capture_analyzer)) |
| 2565 | .Create(); |
| 2566 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2567 | Int16FrameData audio; |
| 2568 | audio.num_channels = 1; |
Valeriia Nemychnikova | f06eb57 | 2018-08-29 08:37:09 | [diff] [blame] | 2569 | SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz); |
| 2570 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2571 | EXPECT_CALL(*mock_capture_analyzer_ptr, Analyze(::testing::_)).Times(1); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2572 | apm->ProcessStream(audio.data.data(), |
| 2573 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2574 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2575 | audio.data.data()); |
Valeriia Nemychnikova | f06eb57 | 2018-08-29 08:37:09 | [diff] [blame] | 2576 | } |
| 2577 | |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2578 | TEST(ApmConfiguration, PreProcessingReceivesRuntimeSettings) { |
| 2579 | auto mock_pre_processor_ptr = |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2580 | new ::testing::NiceMock<test::MockCustomProcessing>(); |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2581 | auto mock_pre_processor = |
| 2582 | std::unique_ptr<CustomProcessing>(mock_pre_processor_ptr); |
| 2583 | rtc::scoped_refptr<AudioProcessing> apm = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 2584 | AudioProcessingBuilderForTesting() |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2585 | .SetRenderPreProcessing(std::move(mock_pre_processor)) |
| 2586 | .Create(); |
| 2587 | apm->SetRuntimeSetting( |
| 2588 | AudioProcessing::RuntimeSetting::CreateCustomRenderSetting(0)); |
| 2589 | |
| 2590 | // RuntimeSettings forwarded during 'Process*Stream' calls. |
| 2591 | // Therefore we have to make one such call. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2592 | Int16FrameData audio; |
| 2593 | audio.num_channels = 1; |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2594 | SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz); |
| 2595 | |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2596 | EXPECT_CALL(*mock_pre_processor_ptr, SetRuntimeSetting(::testing::_)) |
| 2597 | .Times(1); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2598 | apm->ProcessReverseStream( |
| 2599 | audio.data.data(), StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2600 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2601 | audio.data.data()); |
Alex Loiko | 73ec019 | 2018-05-15 08:52:28 | [diff] [blame] | 2602 | } |
| 2603 | |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2604 | class MyEchoControlFactory : public EchoControlFactory { |
| 2605 | public: |
| 2606 | std::unique_ptr<EchoControl> Create(int sample_rate_hz) { |
| 2607 | auto ec = new test::MockEchoControl(); |
Mirko Bonadei | 6a489f2 | 2019-04-09 13:11:12 | [diff] [blame] | 2608 | EXPECT_CALL(*ec, AnalyzeRender(::testing::_)).Times(1); |
| 2609 | EXPECT_CALL(*ec, AnalyzeCapture(::testing::_)).Times(2); |
Per Åhgren | c20a19c | 2019-11-13 10:12:29 | [diff] [blame] | 2610 | EXPECT_CALL(*ec, ProcessCapture(::testing::_, ::testing::_, ::testing::_)) |
| 2611 | .Times(2); |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2612 | return std::unique_ptr<EchoControl>(ec); |
| 2613 | } |
Per Åhgren | ce202a0 | 2019-09-02 15:01:19 | [diff] [blame] | 2614 | |
| 2615 | std::unique_ptr<EchoControl> Create(int sample_rate_hz, |
Per Åhgren | 4e5c709 | 2019-11-01 19:44:11 | [diff] [blame] | 2616 | int num_render_channels, |
| 2617 | int num_capture_channels) { |
Per Åhgren | ce202a0 | 2019-09-02 15:01:19 | [diff] [blame] | 2618 | return Create(sample_rate_hz); |
| 2619 | } |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2620 | }; |
| 2621 | |
| 2622 | TEST(ApmConfiguration, EchoControlInjection) { |
| 2623 | // Verify that apm uses an injected echo controller if one is provided. |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2624 | std::unique_ptr<EchoControlFactory> echo_control_factory( |
| 2625 | new MyEchoControlFactory()); |
| 2626 | |
Alex Loiko | 5825aa6 | 2017-12-18 15:02:40 | [diff] [blame] | 2627 | rtc::scoped_refptr<AudioProcessing> apm = |
Per Åhgren | cc73ed3 | 2020-04-26 21:56:17 | [diff] [blame] | 2628 | AudioProcessingBuilderForTesting() |
Ivo Creusen | 5ec7e12 | 2017-12-22 10:35:59 | [diff] [blame] | 2629 | .SetEchoControlFactory(std::move(echo_control_factory)) |
Alessio Bazzica | be1b898 | 2021-09-17 06:26:10 | [diff] [blame] | 2630 | .Create(); |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2631 | |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2632 | Int16FrameData audio; |
| 2633 | audio.num_channels = 1; |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2634 | SetFrameSampleRate(&audio, AudioProcessing::NativeRate::kSampleRate16kHz); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2635 | apm->ProcessStream(audio.data.data(), |
| 2636 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2637 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2638 | audio.data.data()); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2639 | apm->ProcessReverseStream( |
| 2640 | audio.data.data(), StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2641 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2642 | audio.data.data()); |
| 2643 | apm->ProcessStream(audio.data.data(), |
| 2644 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
| 2645 | StreamConfig(audio.sample_rate_hz, audio.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2646 | audio.data.data()); |
Gustaf Ullberg | 002ef28 | 2017-10-12 13:13:17 | [diff] [blame] | 2647 | } |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2648 | |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2649 | TEST(ApmConfiguration, EchoDetectorInjection) { |
| 2650 | using ::testing::_; |
| 2651 | rtc::scoped_refptr<test::MockEchoDetector> mock_echo_detector = |
| 2652 | rtc::make_ref_counted<::testing::StrictMock<test::MockEchoDetector>>(); |
| 2653 | EXPECT_CALL(*mock_echo_detector, |
| 2654 | Initialize(/*capture_sample_rate_hz=*/16000, _, |
| 2655 | /*render_sample_rate_hz=*/16000, _)) |
| 2656 | .Times(1); |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 2657 | rtc::scoped_refptr<AudioProcessing> apm = |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2658 | AudioProcessingBuilderForTesting() |
| 2659 | .SetEchoDetector(mock_echo_detector) |
| 2660 | .Create(); |
| 2661 | |
| 2662 | // The echo detector is included in processing when enabled. |
| 2663 | EXPECT_CALL(*mock_echo_detector, AnalyzeRenderAudio(_)) |
| 2664 | .WillOnce([](rtc::ArrayView<const float> render_audio) { |
| 2665 | EXPECT_EQ(render_audio.size(), 160u); |
| 2666 | }); |
| 2667 | EXPECT_CALL(*mock_echo_detector, AnalyzeCaptureAudio(_)) |
| 2668 | .WillOnce([](rtc::ArrayView<const float> capture_audio) { |
| 2669 | EXPECT_EQ(capture_audio.size(), 160u); |
| 2670 | }); |
| 2671 | EXPECT_CALL(*mock_echo_detector, GetMetrics()).Times(1); |
| 2672 | |
| 2673 | Int16FrameData frame; |
| 2674 | frame.num_channels = 1; |
| 2675 | SetFrameSampleRate(&frame, 16000); |
| 2676 | |
| 2677 | apm->ProcessReverseStream(frame.data.data(), StreamConfig(16000, 1), |
| 2678 | StreamConfig(16000, 1), frame.data.data()); |
| 2679 | apm->ProcessStream(frame.data.data(), StreamConfig(16000, 1), |
| 2680 | StreamConfig(16000, 1), frame.data.data()); |
| 2681 | |
| 2682 | // When processing rates change, the echo detector is also reinitialized to |
| 2683 | // match those. |
| 2684 | EXPECT_CALL(*mock_echo_detector, |
| 2685 | Initialize(/*capture_sample_rate_hz=*/48000, _, |
| 2686 | /*render_sample_rate_hz=*/16000, _)) |
| 2687 | .Times(1); |
| 2688 | EXPECT_CALL(*mock_echo_detector, |
| 2689 | Initialize(/*capture_sample_rate_hz=*/48000, _, |
| 2690 | /*render_sample_rate_hz=*/48000, _)) |
| 2691 | .Times(1); |
| 2692 | EXPECT_CALL(*mock_echo_detector, AnalyzeRenderAudio(_)) |
| 2693 | .WillOnce([](rtc::ArrayView<const float> render_audio) { |
| 2694 | EXPECT_EQ(render_audio.size(), 480u); |
| 2695 | }); |
| 2696 | EXPECT_CALL(*mock_echo_detector, AnalyzeCaptureAudio(_)) |
| 2697 | .Times(2) |
| 2698 | .WillRepeatedly([](rtc::ArrayView<const float> capture_audio) { |
| 2699 | EXPECT_EQ(capture_audio.size(), 480u); |
| 2700 | }); |
| 2701 | EXPECT_CALL(*mock_echo_detector, GetMetrics()).Times(2); |
| 2702 | |
| 2703 | SetFrameSampleRate(&frame, 48000); |
| 2704 | apm->ProcessStream(frame.data.data(), StreamConfig(48000, 1), |
| 2705 | StreamConfig(48000, 1), frame.data.data()); |
| 2706 | apm->ProcessReverseStream(frame.data.data(), StreamConfig(48000, 1), |
| 2707 | StreamConfig(48000, 1), frame.data.data()); |
| 2708 | apm->ProcessStream(frame.data.data(), StreamConfig(48000, 1), |
| 2709 | StreamConfig(48000, 1), frame.data.data()); |
| 2710 | } |
| 2711 | |
| 2712 | rtc::scoped_refptr<AudioProcessing> CreateApm(bool mobile_aec) { |
| 2713 | // Enable residual echo detection, for stats. |
| 2714 | rtc::scoped_refptr<AudioProcessing> apm = |
| 2715 | AudioProcessingBuilderForTesting() |
| 2716 | .SetEchoDetector(CreateEchoDetector()) |
| 2717 | .Create(); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2718 | if (!apm) { |
| 2719 | return apm; |
| 2720 | } |
| 2721 | |
| 2722 | ProcessingConfig processing_config = { |
| 2723 | {{32000, 1}, {32000, 1}, {32000, 1}, {32000, 1}}}; |
| 2724 | |
| 2725 | if (apm->Initialize(processing_config) != 0) { |
| 2726 | return nullptr; |
| 2727 | } |
| 2728 | |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2729 | // Disable all components except for an AEC. |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 2730 | AudioProcessing::Config apm_config; |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 2731 | apm_config.high_pass_filter.enabled = false; |
Sam Zackrisson | 41478c7 | 2019-10-15 08:10:26 | [diff] [blame] | 2732 | apm_config.gain_controller1.enabled = false; |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 2733 | apm_config.gain_controller2.enabled = false; |
| 2734 | apm_config.echo_canceller.enabled = true; |
Per Åhgren | 8607f84 | 2019-04-12 20:02:26 | [diff] [blame] | 2735 | apm_config.echo_canceller.mobile_mode = mobile_aec; |
saza | 0bad15f | 2019-10-16 09:46:11 | [diff] [blame] | 2736 | apm_config.noise_suppression.enabled = false; |
Sam Zackrisson | cdf0e6d | 2018-09-17 09:05:17 | [diff] [blame] | 2737 | apm->ApplyConfig(apm_config); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2738 | return apm; |
| 2739 | } |
| 2740 | |
| 2741 | #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) || defined(WEBRTC_MAC) |
| 2742 | #define MAYBE_ApmStatistics DISABLED_ApmStatistics |
| 2743 | #else |
| 2744 | #define MAYBE_ApmStatistics ApmStatistics |
| 2745 | #endif |
| 2746 | |
Per Åhgren | 8607f84 | 2019-04-12 20:02:26 | [diff] [blame] | 2747 | TEST(MAYBE_ApmStatistics, AECEnabledTest) { |
| 2748 | // Set up APM with AEC3 and process some audio. |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 2749 | rtc::scoped_refptr<AudioProcessing> apm = CreateApm(false); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2750 | ASSERT_TRUE(apm); |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 2751 | AudioProcessing::Config apm_config; |
| 2752 | apm_config.echo_canceller.enabled = true; |
Per Åhgren | 200feba1c | 2019-03-06 03:16:46 | [diff] [blame] | 2753 | apm->ApplyConfig(apm_config); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2754 | |
| 2755 | // Set up an audioframe. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2756 | Int16FrameData frame; |
| 2757 | frame.num_channels = 1; |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2758 | SetFrameSampleRate(&frame, AudioProcessing::NativeRate::kSampleRate32kHz); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2759 | |
| 2760 | // Fill the audio frame with a sawtooth pattern. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2761 | int16_t* ptr = frame.data.data(); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2762 | for (size_t i = 0; i < frame.kMaxDataSizeSamples; i++) { |
| 2763 | ptr[i] = 10000 * ((i % 3) - 1); |
| 2764 | } |
| 2765 | |
| 2766 | // Do some processing. |
| 2767 | for (int i = 0; i < 200; i++) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2768 | EXPECT_EQ(apm->ProcessReverseStream( |
| 2769 | frame.data.data(), |
| 2770 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2771 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2772 | frame.data.data()), |
| 2773 | 0); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2774 | EXPECT_EQ(apm->set_stream_delay_ms(0), 0); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2775 | EXPECT_EQ(apm->ProcessStream( |
| 2776 | frame.data.data(), |
| 2777 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2778 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2779 | frame.data.data()), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2780 | 0); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2781 | } |
| 2782 | |
| 2783 | // Test statistics interface. |
Per Åhgren | cf4c872 | 2019-12-30 13:32:14 | [diff] [blame] | 2784 | AudioProcessingStats stats = apm->GetStatistics(); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2785 | // We expect all statistics to be set and have a sensible value. |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2786 | ASSERT_TRUE(stats.residual_echo_likelihood.has_value()); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2787 | EXPECT_GE(*stats.residual_echo_likelihood, 0.0); |
| 2788 | EXPECT_LE(*stats.residual_echo_likelihood, 1.0); |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2789 | ASSERT_TRUE(stats.residual_echo_likelihood_recent_max.has_value()); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2790 | EXPECT_GE(*stats.residual_echo_likelihood_recent_max, 0.0); |
| 2791 | EXPECT_LE(*stats.residual_echo_likelihood_recent_max, 1.0); |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2792 | ASSERT_TRUE(stats.echo_return_loss.has_value()); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2793 | EXPECT_NE(*stats.echo_return_loss, -100.0); |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2794 | ASSERT_TRUE(stats.echo_return_loss_enhancement.has_value()); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2795 | EXPECT_NE(*stats.echo_return_loss_enhancement, -100.0); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2796 | } |
| 2797 | |
| 2798 | TEST(MAYBE_ApmStatistics, AECMEnabledTest) { |
| 2799 | // Set up APM with AECM and process some audio. |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 2800 | rtc::scoped_refptr<AudioProcessing> apm = CreateApm(true); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2801 | ASSERT_TRUE(apm); |
| 2802 | |
| 2803 | // Set up an audioframe. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2804 | Int16FrameData frame; |
| 2805 | frame.num_channels = 1; |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2806 | SetFrameSampleRate(&frame, AudioProcessing::NativeRate::kSampleRate32kHz); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2807 | |
| 2808 | // Fill the audio frame with a sawtooth pattern. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2809 | int16_t* ptr = frame.data.data(); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2810 | for (size_t i = 0; i < frame.kMaxDataSizeSamples; i++) { |
| 2811 | ptr[i] = 10000 * ((i % 3) - 1); |
| 2812 | } |
| 2813 | |
| 2814 | // Do some processing. |
| 2815 | for (int i = 0; i < 200; i++) { |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2816 | EXPECT_EQ(apm->ProcessReverseStream( |
| 2817 | frame.data.data(), |
| 2818 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2819 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2820 | frame.data.data()), |
| 2821 | 0); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2822 | EXPECT_EQ(apm->set_stream_delay_ms(0), 0); |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2823 | EXPECT_EQ(apm->ProcessStream( |
| 2824 | frame.data.data(), |
| 2825 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2826 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2827 | frame.data.data()), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2828 | 0); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2829 | } |
| 2830 | |
| 2831 | // Test statistics interface. |
Per Åhgren | cf4c872 | 2019-12-30 13:32:14 | [diff] [blame] | 2832 | AudioProcessingStats stats = apm->GetStatistics(); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2833 | // We expect only the residual echo detector statistics to be set and have a |
| 2834 | // sensible value. |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2835 | ASSERT_TRUE(stats.residual_echo_likelihood.has_value()); |
| 2836 | EXPECT_GE(*stats.residual_echo_likelihood, 0.0); |
| 2837 | EXPECT_LE(*stats.residual_echo_likelihood, 1.0); |
| 2838 | ASSERT_TRUE(stats.residual_echo_likelihood_recent_max.has_value()); |
| 2839 | EXPECT_GE(*stats.residual_echo_likelihood_recent_max, 0.0); |
| 2840 | EXPECT_LE(*stats.residual_echo_likelihood_recent_max, 1.0); |
| 2841 | EXPECT_FALSE(stats.echo_return_loss.has_value()); |
| 2842 | EXPECT_FALSE(stats.echo_return_loss_enhancement.has_value()); |
Ivo Creusen | ae026096 | 2017-11-20 12:07:16 | [diff] [blame] | 2843 | } |
Sam Zackrisson | b24c00f | 2018-11-26 15:18:25 | [diff] [blame] | 2844 | |
Alessio Bazzica | 1db0a26 | 2022-02-15 14:18:09 | [diff] [blame] | 2845 | TEST(ApmStatistics, DoNotReportVoiceDetectedStat) { |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2846 | ProcessingConfig processing_config = { |
| 2847 | {{32000, 1}, {32000, 1}, {32000, 1}, {32000, 1}}}; |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2848 | |
| 2849 | // Set up an audioframe. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2850 | Int16FrameData frame; |
| 2851 | frame.num_channels = 1; |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2852 | SetFrameSampleRate(&frame, AudioProcessing::NativeRate::kSampleRate32kHz); |
| 2853 | |
| 2854 | // Fill the audio frame with a sawtooth pattern. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2855 | int16_t* ptr = frame.data.data(); |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2856 | for (size_t i = 0; i < frame.kMaxDataSizeSamples; i++) { |
| 2857 | ptr[i] = 10000 * ((i % 3) - 1); |
| 2858 | } |
| 2859 | |
Niels Möller | 4f776ac | 2021-07-02 09:30:54 | [diff] [blame] | 2860 | rtc::scoped_refptr<AudioProcessing> apm = |
| 2861 | AudioProcessingBuilderForTesting().Create(); |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2862 | apm->Initialize(processing_config); |
| 2863 | |
Alessio Bazzica | 1db0a26 | 2022-02-15 14:18:09 | [diff] [blame] | 2864 | // No metric should be reported. |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2865 | EXPECT_EQ( |
| 2866 | apm->ProcessStream(frame.data.data(), |
| 2867 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2868 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
Per Åhgren | dc5522b | 2020-03-19 13:55:58 | [diff] [blame] | 2869 | frame.data.data()), |
Per Åhgren | 2507f8c | 2020-03-19 11:33:29 | [diff] [blame] | 2870 | 0); |
Alessio Bazzica | 1db0a26 | 2022-02-15 14:18:09 | [diff] [blame] | 2871 | EXPECT_FALSE(apm->GetStatistics().voice_detected.has_value()); |
Sam Zackrisson | 4db667b | 2018-12-21 15:29:27 | [diff] [blame] | 2872 | } |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2873 | |
Sam Zackrisson | 03cb7e5 | 2021-12-06 14:40:04 | [diff] [blame] | 2874 | TEST(ApmStatistics, GetStatisticsReportsNoEchoDetectorStatsWhenDisabled) { |
| 2875 | rtc::scoped_refptr<AudioProcessing> apm = |
| 2876 | AudioProcessingBuilderForTesting().Create(); |
| 2877 | Int16FrameData frame; |
| 2878 | frame.num_channels = 1; |
| 2879 | SetFrameSampleRate(&frame, AudioProcessing::NativeRate::kSampleRate32kHz); |
| 2880 | ASSERT_EQ( |
| 2881 | apm->ProcessStream(frame.data.data(), |
| 2882 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2883 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2884 | frame.data.data()), |
| 2885 | 0); |
| 2886 | // Echo detector is disabled by default, no stats reported. |
| 2887 | AudioProcessingStats stats = apm->GetStatistics(); |
| 2888 | EXPECT_FALSE(stats.residual_echo_likelihood.has_value()); |
| 2889 | EXPECT_FALSE(stats.residual_echo_likelihood_recent_max.has_value()); |
| 2890 | } |
| 2891 | |
| 2892 | TEST(ApmStatistics, GetStatisticsReportsEchoDetectorStatsWhenEnabled) { |
| 2893 | // Create APM with an echo detector injected. |
| 2894 | rtc::scoped_refptr<AudioProcessing> apm = |
| 2895 | AudioProcessingBuilderForTesting() |
| 2896 | .SetEchoDetector(CreateEchoDetector()) |
| 2897 | .Create(); |
| 2898 | Int16FrameData frame; |
| 2899 | frame.num_channels = 1; |
| 2900 | SetFrameSampleRate(&frame, AudioProcessing::NativeRate::kSampleRate32kHz); |
| 2901 | // Echo detector enabled: Report stats. |
| 2902 | ASSERT_EQ( |
| 2903 | apm->ProcessStream(frame.data.data(), |
| 2904 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2905 | StreamConfig(frame.sample_rate_hz, frame.num_channels), |
| 2906 | frame.data.data()), |
| 2907 | 0); |
| 2908 | AudioProcessingStats stats = apm->GetStatistics(); |
| 2909 | EXPECT_TRUE(stats.residual_echo_likelihood.has_value()); |
| 2910 | EXPECT_TRUE(stats.residual_echo_likelihood_recent_max.has_value()); |
| 2911 | } |
| 2912 | |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2913 | TEST(ApmConfiguration, HandlingOfRateAndChannelCombinations) { |
| 2914 | std::array<int, 3> sample_rates_hz = {16000, 32000, 48000}; |
| 2915 | std::array<int, 2> render_channel_counts = {1, 7}; |
| 2916 | std::array<int, 2> capture_channel_counts = {1, 7}; |
| 2917 | RunApmRateAndChannelTest(sample_rates_hz, render_channel_counts, |
| 2918 | capture_channel_counts); |
| 2919 | } |
| 2920 | |
| 2921 | TEST(ApmConfiguration, HandlingOfChannelCombinations) { |
| 2922 | std::array<int, 1> sample_rates_hz = {48000}; |
| 2923 | std::array<int, 8> render_channel_counts = {1, 2, 3, 4, 5, 6, 7, 8}; |
| 2924 | std::array<int, 8> capture_channel_counts = {1, 2, 3, 4, 5, 6, 7, 8}; |
| 2925 | RunApmRateAndChannelTest(sample_rates_hz, render_channel_counts, |
| 2926 | capture_channel_counts); |
| 2927 | } |
| 2928 | |
| 2929 | TEST(ApmConfiguration, HandlingOfRateCombinations) { |
Sam Zackrisson | 3bd444f | 2022-08-03 12:37:00 | [diff] [blame] | 2930 | // Test rates <= 96000 logged by Chrome UMA: |
| 2931 | // - WebRTC.AudioInputSampleRate |
| 2932 | // - WebRTC.AudioOutputSampleRate |
| 2933 | // Higher rates are tested in AudioProcessingTest.Format, to keep the number |
| 2934 | // of combinations in this test manageable. |
| 2935 | std::array<int, 9> sample_rates_hz = {8000, 11025, 16000, 22050, 32000, |
| 2936 | 44100, 48000, 88200, 96000}; |
Per Åhgren | 3e8bf28 | 2019-08-29 21:38:40 | [diff] [blame] | 2937 | std::array<int, 1> render_channel_counts = {2}; |
| 2938 | std::array<int, 1> capture_channel_counts = {2}; |
| 2939 | RunApmRateAndChannelTest(sample_rates_hz, render_channel_counts, |
| 2940 | capture_channel_counts); |
| 2941 | } |
| 2942 | |
Yves Gerey | 1fce3f8 | 2019-12-05 16:45:31 | [diff] [blame] | 2943 | TEST(ApmConfiguration, SelfAssignment) { |
| 2944 | // At some point memory sanitizer was complaining about self-assigment. |
| 2945 | // Make sure we don't regress. |
| 2946 | AudioProcessing::Config config; |
| 2947 | AudioProcessing::Config* config2 = &config; |
| 2948 | *config2 = *config2; // Workaround -Wself-assign-overloaded |
| 2949 | SUCCEED(); // Real success is absence of defects from asan/msan/ubsan. |
| 2950 | } |
| 2951 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 2952 | TEST(AudioProcessing, GainController1ConfigEqual) { |
| 2953 | AudioProcessing::Config::GainController1 a; |
| 2954 | AudioProcessing::Config::GainController1 b; |
| 2955 | EXPECT_EQ(a, b); |
| 2956 | |
| 2957 | Toggle(a.enabled); |
| 2958 | b.enabled = a.enabled; |
| 2959 | EXPECT_EQ(a, b); |
| 2960 | |
| 2961 | a.mode = AudioProcessing::Config::GainController1::Mode::kAdaptiveDigital; |
| 2962 | b.mode = a.mode; |
| 2963 | EXPECT_EQ(a, b); |
| 2964 | |
| 2965 | a.target_level_dbfs++; |
| 2966 | b.target_level_dbfs = a.target_level_dbfs; |
| 2967 | EXPECT_EQ(a, b); |
| 2968 | |
| 2969 | a.compression_gain_db++; |
| 2970 | b.compression_gain_db = a.compression_gain_db; |
| 2971 | EXPECT_EQ(a, b); |
| 2972 | |
| 2973 | Toggle(a.enable_limiter); |
| 2974 | b.enable_limiter = a.enable_limiter; |
| 2975 | EXPECT_EQ(a, b); |
| 2976 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 2977 | auto& a_analog = a.analog_gain_controller; |
| 2978 | auto& b_analog = b.analog_gain_controller; |
| 2979 | |
| 2980 | Toggle(a_analog.enabled); |
| 2981 | b_analog.enabled = a_analog.enabled; |
| 2982 | EXPECT_EQ(a, b); |
| 2983 | |
| 2984 | a_analog.startup_min_volume++; |
| 2985 | b_analog.startup_min_volume = a_analog.startup_min_volume; |
| 2986 | EXPECT_EQ(a, b); |
| 2987 | |
| 2988 | a_analog.clipped_level_min++; |
| 2989 | b_analog.clipped_level_min = a_analog.clipped_level_min; |
| 2990 | EXPECT_EQ(a, b); |
| 2991 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 2992 | Toggle(a_analog.enable_digital_adaptive); |
| 2993 | b_analog.enable_digital_adaptive = a_analog.enable_digital_adaptive; |
| 2994 | EXPECT_EQ(a, b); |
| 2995 | } |
| 2996 | |
| 2997 | // Checks that one differing parameter is sufficient to make two configs |
| 2998 | // different. |
| 2999 | TEST(AudioProcessing, GainController1ConfigNotEqual) { |
| 3000 | AudioProcessing::Config::GainController1 a; |
| 3001 | const AudioProcessing::Config::GainController1 b; |
| 3002 | |
| 3003 | Toggle(a.enabled); |
| 3004 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3005 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3006 | |
| 3007 | a.mode = AudioProcessing::Config::GainController1::Mode::kAdaptiveDigital; |
| 3008 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3009 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3010 | |
| 3011 | a.target_level_dbfs++; |
| 3012 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3013 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3014 | |
| 3015 | a.compression_gain_db++; |
| 3016 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3017 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3018 | |
| 3019 | Toggle(a.enable_limiter); |
| 3020 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3021 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3022 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3023 | auto& a_analog = a.analog_gain_controller; |
| 3024 | const auto& b_analog = b.analog_gain_controller; |
| 3025 | |
| 3026 | Toggle(a_analog.enabled); |
| 3027 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3028 | a_analog = b_analog; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3029 | |
| 3030 | a_analog.startup_min_volume++; |
| 3031 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3032 | a_analog = b_analog; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3033 | |
| 3034 | a_analog.clipped_level_min++; |
| 3035 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3036 | a_analog = b_analog; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3037 | |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3038 | Toggle(a_analog.enable_digital_adaptive); |
| 3039 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3040 | a_analog = b_analog; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3041 | } |
| 3042 | |
| 3043 | TEST(AudioProcessing, GainController2ConfigEqual) { |
| 3044 | AudioProcessing::Config::GainController2 a; |
| 3045 | AudioProcessing::Config::GainController2 b; |
| 3046 | EXPECT_EQ(a, b); |
| 3047 | |
| 3048 | Toggle(a.enabled); |
| 3049 | b.enabled = a.enabled; |
| 3050 | EXPECT_EQ(a, b); |
| 3051 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3052 | a.fixed_digital.gain_db += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3053 | b.fixed_digital.gain_db = a.fixed_digital.gain_db; |
| 3054 | EXPECT_EQ(a, b); |
| 3055 | |
| 3056 | auto& a_adaptive = a.adaptive_digital; |
| 3057 | auto& b_adaptive = b.adaptive_digital; |
| 3058 | |
| 3059 | Toggle(a_adaptive.enabled); |
| 3060 | b_adaptive.enabled = a_adaptive.enabled; |
| 3061 | EXPECT_EQ(a, b); |
| 3062 | |
Alessio Bazzica | a850e6c | 2021-10-04 11:35:55 | [diff] [blame] | 3063 | a_adaptive.headroom_db += 1.0f; |
| 3064 | b_adaptive.headroom_db = a_adaptive.headroom_db; |
| 3065 | EXPECT_EQ(a, b); |
| 3066 | |
| 3067 | a_adaptive.max_gain_db += 1.0f; |
| 3068 | b_adaptive.max_gain_db = a_adaptive.max_gain_db; |
| 3069 | EXPECT_EQ(a, b); |
| 3070 | |
| 3071 | a_adaptive.initial_gain_db += 1.0f; |
| 3072 | b_adaptive.initial_gain_db = a_adaptive.initial_gain_db; |
| 3073 | EXPECT_EQ(a, b); |
| 3074 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3075 | a_adaptive.max_gain_change_db_per_second += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3076 | b_adaptive.max_gain_change_db_per_second = |
| 3077 | a_adaptive.max_gain_change_db_per_second; |
| 3078 | EXPECT_EQ(a, b); |
| 3079 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3080 | a_adaptive.max_output_noise_level_dbfs += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3081 | b_adaptive.max_output_noise_level_dbfs = |
| 3082 | a_adaptive.max_output_noise_level_dbfs; |
| 3083 | EXPECT_EQ(a, b); |
| 3084 | } |
| 3085 | |
| 3086 | // Checks that one differing parameter is sufficient to make two configs |
| 3087 | // different. |
| 3088 | TEST(AudioProcessing, GainController2ConfigNotEqual) { |
| 3089 | AudioProcessing::Config::GainController2 a; |
| 3090 | const AudioProcessing::Config::GainController2 b; |
| 3091 | |
| 3092 | Toggle(a.enabled); |
| 3093 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3094 | a = b; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3095 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3096 | a.fixed_digital.gain_db += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3097 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3098 | a.fixed_digital = b.fixed_digital; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3099 | |
| 3100 | auto& a_adaptive = a.adaptive_digital; |
| 3101 | const auto& b_adaptive = b.adaptive_digital; |
| 3102 | |
| 3103 | Toggle(a_adaptive.enabled); |
| 3104 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3105 | a_adaptive = b_adaptive; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3106 | |
Alessio Bazzica | a850e6c | 2021-10-04 11:35:55 | [diff] [blame] | 3107 | a_adaptive.headroom_db += 1.0f; |
| 3108 | EXPECT_NE(a, b); |
| 3109 | a_adaptive = b_adaptive; |
| 3110 | |
| 3111 | a_adaptive.max_gain_db += 1.0f; |
| 3112 | EXPECT_NE(a, b); |
| 3113 | a_adaptive = b_adaptive; |
| 3114 | |
| 3115 | a_adaptive.initial_gain_db += 1.0f; |
| 3116 | EXPECT_NE(a, b); |
| 3117 | a_adaptive = b_adaptive; |
| 3118 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3119 | a_adaptive.max_gain_change_db_per_second += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3120 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3121 | a_adaptive = b_adaptive; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3122 | |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3123 | a_adaptive.max_output_noise_level_dbfs += 1.0f; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3124 | EXPECT_NE(a, b); |
Alessio Bazzica | a2efd15 | 2021-04-29 14:17:49 | [diff] [blame] | 3125 | a_adaptive = b_adaptive; |
Alessio Bazzica | 3438a93 | 2020-10-14 10:47:50 | [diff] [blame] | 3126 | } |
| 3127 | |
Sam Zackrisson | 5dd5482 | 2022-11-17 10:26:58 | [diff] [blame] | 3128 | struct ApmFormatHandlingTestParams { |
| 3129 | enum class ExpectedOutput { |
| 3130 | kErrorAndUnmodified, |
| 3131 | kErrorAndSilence, |
| 3132 | kErrorAndCopyOfFirstChannel, |
| 3133 | kErrorAndExactCopy, |
| 3134 | kNoError |
| 3135 | }; |
| 3136 | |
| 3137 | StreamConfig input_config; |
| 3138 | StreamConfig output_config; |
| 3139 | ExpectedOutput expected_output; |
| 3140 | }; |
| 3141 | |
| 3142 | class ApmFormatHandlingTest |
| 3143 | : public ::testing::TestWithParam< |
| 3144 | std::tuple<StreamDirection, ApmFormatHandlingTestParams>> { |
| 3145 | public: |
| 3146 | ApmFormatHandlingTest() |
| 3147 | : stream_direction_(std::get<0>(GetParam())), |
| 3148 | test_params_(std::get<1>(GetParam())) {} |
| 3149 | |
| 3150 | protected: |
| 3151 | ::testing::Message ProduceDebugMessage() { |
| 3152 | return ::testing::Message() |
| 3153 | << "input sample_rate_hz=" |
| 3154 | << test_params_.input_config.sample_rate_hz() |
| 3155 | << " num_channels=" << test_params_.input_config.num_channels() |
| 3156 | << ", output sample_rate_hz=" |
| 3157 | << test_params_.output_config.sample_rate_hz() |
| 3158 | << " num_channels=" << test_params_.output_config.num_channels() |
| 3159 | << ", stream_direction=" << stream_direction_ << ", expected_output=" |
| 3160 | << static_cast<int>(test_params_.expected_output); |
| 3161 | } |
| 3162 | |
| 3163 | StreamDirection stream_direction_; |
| 3164 | ApmFormatHandlingTestParams test_params_; |
| 3165 | }; |
| 3166 | |
| 3167 | INSTANTIATE_TEST_SUITE_P( |
| 3168 | FormatValidation, |
| 3169 | ApmFormatHandlingTest, |
| 3170 | testing::Combine( |
| 3171 | ::testing::Values(kForward, kReverse), |
| 3172 | ::testing::Values( |
| 3173 | // Test cases with values on the boundary of legal ranges. |
| 3174 | ApmFormatHandlingTestParams{ |
| 3175 | StreamConfig(16000, 1), StreamConfig(8000, 1), |
| 3176 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3177 | ApmFormatHandlingTestParams{ |
| 3178 | StreamConfig(8000, 1), StreamConfig(16000, 1), |
| 3179 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3180 | ApmFormatHandlingTestParams{ |
| 3181 | StreamConfig(384000, 1), StreamConfig(16000, 1), |
| 3182 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3183 | ApmFormatHandlingTestParams{ |
| 3184 | StreamConfig(16000, 1), StreamConfig(384000, 1), |
| 3185 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3186 | ApmFormatHandlingTestParams{ |
| 3187 | StreamConfig(16000, 2), StreamConfig(16000, 1), |
| 3188 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3189 | ApmFormatHandlingTestParams{ |
| 3190 | StreamConfig(16000, 3), StreamConfig(16000, 3), |
| 3191 | ApmFormatHandlingTestParams::ExpectedOutput::kNoError}, |
| 3192 | |
Sam Zackrisson | 06cba44 | 2022-11-21 15:32:42 | [diff] [blame] | 3193 | // Supported but incompatible formats. |
| 3194 | ApmFormatHandlingTestParams{ |
| 3195 | StreamConfig(16000, 3), StreamConfig(16000, 2), |
| 3196 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3197 | kErrorAndCopyOfFirstChannel}, |
| 3198 | ApmFormatHandlingTestParams{ |
| 3199 | StreamConfig(16000, 3), StreamConfig(16000, 4), |
| 3200 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3201 | kErrorAndCopyOfFirstChannel}, |
| 3202 | |
Sam Zackrisson | 5dd5482 | 2022-11-17 10:26:58 | [diff] [blame] | 3203 | // Unsupported format and input / output mismatch. |
| 3204 | ApmFormatHandlingTestParams{ |
| 3205 | StreamConfig(7900, 1), StreamConfig(16000, 1), |
| 3206 | ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence}, |
| 3207 | ApmFormatHandlingTestParams{ |
| 3208 | StreamConfig(16000, 1), StreamConfig(7900, 1), |
| 3209 | ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence}, |
| 3210 | ApmFormatHandlingTestParams{ |
| 3211 | StreamConfig(390000, 1), StreamConfig(16000, 1), |
| 3212 | ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence}, |
| 3213 | ApmFormatHandlingTestParams{ |
| 3214 | StreamConfig(16000, 1), StreamConfig(390000, 1), |
| 3215 | ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence}, |
| 3216 | ApmFormatHandlingTestParams{ |
| 3217 | StreamConfig(-16000, 1), StreamConfig(16000, 1), |
| 3218 | ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence}, |
| 3219 | |
| 3220 | // Unsupported format but input / output formats match. |
| 3221 | ApmFormatHandlingTestParams{StreamConfig(7900, 1), |
| 3222 | StreamConfig(7900, 1), |
| 3223 | ApmFormatHandlingTestParams:: |
| 3224 | ExpectedOutput::kErrorAndExactCopy}, |
| 3225 | ApmFormatHandlingTestParams{StreamConfig(390000, 1), |
| 3226 | StreamConfig(390000, 1), |
| 3227 | ApmFormatHandlingTestParams:: |
| 3228 | ExpectedOutput::kErrorAndExactCopy}, |
| 3229 | |
| 3230 | // Unsupported but identical sample rate, channel mismatch. |
| 3231 | ApmFormatHandlingTestParams{ |
| 3232 | StreamConfig(7900, 1), StreamConfig(7900, 2), |
| 3233 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3234 | kErrorAndCopyOfFirstChannel}, |
| 3235 | ApmFormatHandlingTestParams{ |
| 3236 | StreamConfig(7900, 2), StreamConfig(7900, 1), |
| 3237 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3238 | kErrorAndCopyOfFirstChannel}, |
| 3239 | |
| 3240 | // Test cases with meaningless output format. |
| 3241 | ApmFormatHandlingTestParams{ |
| 3242 | StreamConfig(16000, 1), StreamConfig(-16000, 1), |
| 3243 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3244 | kErrorAndUnmodified}, |
| 3245 | ApmFormatHandlingTestParams{ |
| 3246 | StreamConfig(-16000, 1), StreamConfig(-16000, 1), |
| 3247 | ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3248 | kErrorAndUnmodified}))); |
| 3249 | |
| 3250 | TEST_P(ApmFormatHandlingTest, IntApi) { |
| 3251 | SCOPED_TRACE(ProduceDebugMessage()); |
| 3252 | |
| 3253 | // Set up input and output data. |
| 3254 | const size_t num_input_samples = |
| 3255 | test_params_.input_config.num_channels() * |
| 3256 | std::abs(test_params_.input_config.sample_rate_hz() / 100); |
| 3257 | const size_t num_output_samples = |
| 3258 | test_params_.output_config.num_channels() * |
| 3259 | std::abs(test_params_.output_config.sample_rate_hz() / 100); |
| 3260 | std::vector<int16_t> input_block(num_input_samples); |
| 3261 | for (int i = 0; i < static_cast<int>(input_block.size()); ++i) { |
| 3262 | input_block[i] = i; |
| 3263 | } |
| 3264 | std::vector<int16_t> output_block(num_output_samples); |
| 3265 | constexpr int kUnlikelyOffset = 37; |
| 3266 | for (int i = 0; i < static_cast<int>(output_block.size()); ++i) { |
| 3267 | output_block[i] = i - kUnlikelyOffset; |
| 3268 | } |
| 3269 | |
| 3270 | // Call APM. |
| 3271 | rtc::scoped_refptr<AudioProcessing> ap = |
| 3272 | AudioProcessingBuilderForTesting().Create(); |
| 3273 | int error; |
| 3274 | if (stream_direction_ == kForward) { |
| 3275 | error = ap->ProcessStream(input_block.data(), test_params_.input_config, |
| 3276 | test_params_.output_config, output_block.data()); |
| 3277 | } else { |
| 3278 | error = ap->ProcessReverseStream( |
| 3279 | input_block.data(), test_params_.input_config, |
| 3280 | test_params_.output_config, output_block.data()); |
| 3281 | } |
| 3282 | |
| 3283 | // Check output. |
| 3284 | switch (test_params_.expected_output) { |
| 3285 | case ApmFormatHandlingTestParams::ExpectedOutput::kNoError: |
| 3286 | EXPECT_EQ(error, AudioProcessing::kNoError); |
| 3287 | break; |
| 3288 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndUnmodified: |
| 3289 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3290 | for (int i = 0; i < static_cast<int>(output_block.size()); ++i) { |
| 3291 | EXPECT_EQ(output_block[i], i - kUnlikelyOffset); |
| 3292 | } |
| 3293 | break; |
| 3294 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence: |
| 3295 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3296 | for (int i = 0; i < static_cast<int>(output_block.size()); ++i) { |
| 3297 | EXPECT_EQ(output_block[i], 0); |
| 3298 | } |
| 3299 | break; |
| 3300 | case ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3301 | kErrorAndCopyOfFirstChannel: |
| 3302 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3303 | for (size_t ch = 0; ch < test_params_.output_config.num_channels(); |
| 3304 | ++ch) { |
| 3305 | for (size_t i = 0; i < test_params_.output_config.num_frames(); ++i) { |
| 3306 | EXPECT_EQ( |
| 3307 | output_block[ch + i * test_params_.output_config.num_channels()], |
| 3308 | static_cast<int16_t>(i * |
| 3309 | test_params_.input_config.num_channels())); |
| 3310 | } |
| 3311 | } |
| 3312 | break; |
| 3313 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndExactCopy: |
| 3314 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3315 | for (int i = 0; i < static_cast<int>(output_block.size()); ++i) { |
| 3316 | EXPECT_EQ(output_block[i], i); |
| 3317 | } |
| 3318 | break; |
| 3319 | } |
| 3320 | } |
| 3321 | |
| 3322 | TEST_P(ApmFormatHandlingTest, FloatApi) { |
| 3323 | SCOPED_TRACE(ProduceDebugMessage()); |
| 3324 | |
| 3325 | // Set up input and output data. |
| 3326 | const size_t input_samples_per_channel = |
| 3327 | std::abs(test_params_.input_config.sample_rate_hz()) / 100; |
| 3328 | const size_t output_samples_per_channel = |
| 3329 | std::abs(test_params_.output_config.sample_rate_hz()) / 100; |
| 3330 | const size_t input_num_channels = test_params_.input_config.num_channels(); |
| 3331 | const size_t output_num_channels = test_params_.output_config.num_channels(); |
| 3332 | ChannelBuffer<float> input_block(input_samples_per_channel, |
| 3333 | input_num_channels); |
| 3334 | ChannelBuffer<float> output_block(output_samples_per_channel, |
| 3335 | output_num_channels); |
| 3336 | for (size_t ch = 0; ch < input_num_channels; ++ch) { |
| 3337 | for (size_t i = 0; i < input_samples_per_channel; ++i) { |
| 3338 | input_block.channels()[ch][i] = ch + i * input_num_channels; |
| 3339 | } |
| 3340 | } |
| 3341 | constexpr int kUnlikelyOffset = 37; |
| 3342 | for (size_t ch = 0; ch < output_num_channels; ++ch) { |
| 3343 | for (size_t i = 0; i < output_samples_per_channel; ++i) { |
| 3344 | output_block.channels()[ch][i] = |
| 3345 | ch + i * output_num_channels - kUnlikelyOffset; |
| 3346 | } |
| 3347 | } |
| 3348 | |
| 3349 | // Call APM. |
| 3350 | rtc::scoped_refptr<AudioProcessing> ap = |
| 3351 | AudioProcessingBuilderForTesting().Create(); |
| 3352 | int error; |
| 3353 | if (stream_direction_ == kForward) { |
| 3354 | error = |
| 3355 | ap->ProcessStream(input_block.channels(), test_params_.input_config, |
| 3356 | test_params_.output_config, output_block.channels()); |
| 3357 | } else { |
| 3358 | error = ap->ProcessReverseStream( |
| 3359 | input_block.channels(), test_params_.input_config, |
| 3360 | test_params_.output_config, output_block.channels()); |
| 3361 | } |
| 3362 | |
| 3363 | // Check output. |
| 3364 | switch (test_params_.expected_output) { |
| 3365 | case ApmFormatHandlingTestParams::ExpectedOutput::kNoError: |
| 3366 | EXPECT_EQ(error, AudioProcessing::kNoError); |
| 3367 | break; |
| 3368 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndUnmodified: |
| 3369 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3370 | for (size_t ch = 0; ch < output_num_channels; ++ch) { |
| 3371 | for (size_t i = 0; i < output_samples_per_channel; ++i) { |
| 3372 | EXPECT_EQ(output_block.channels()[ch][i], |
| 3373 | ch + i * output_num_channels - kUnlikelyOffset); |
| 3374 | } |
| 3375 | } |
| 3376 | break; |
| 3377 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndSilence: |
| 3378 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3379 | for (size_t ch = 0; ch < output_num_channels; ++ch) { |
| 3380 | for (size_t i = 0; i < output_samples_per_channel; ++i) { |
| 3381 | EXPECT_EQ(output_block.channels()[ch][i], 0); |
| 3382 | } |
| 3383 | } |
| 3384 | break; |
| 3385 | case ApmFormatHandlingTestParams::ExpectedOutput:: |
| 3386 | kErrorAndCopyOfFirstChannel: |
| 3387 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3388 | for (size_t ch = 0; ch < output_num_channels; ++ch) { |
| 3389 | for (size_t i = 0; i < output_samples_per_channel; ++i) { |
| 3390 | EXPECT_EQ(output_block.channels()[ch][i], |
| 3391 | input_block.channels()[0][i]); |
| 3392 | } |
| 3393 | } |
| 3394 | break; |
| 3395 | case ApmFormatHandlingTestParams::ExpectedOutput::kErrorAndExactCopy: |
| 3396 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3397 | for (size_t ch = 0; ch < output_num_channels; ++ch) { |
| 3398 | for (size_t i = 0; i < output_samples_per_channel; ++i) { |
| 3399 | EXPECT_EQ(output_block.channels()[ch][i], |
| 3400 | input_block.channels()[ch][i]); |
| 3401 | } |
| 3402 | } |
| 3403 | break; |
| 3404 | } |
| 3405 | } |
| 3406 | |
| 3407 | TEST(ApmAnalyzeReverseStreamFormatTest, AnalyzeReverseStream) { |
| 3408 | for (auto&& [input_config, expect_error] : |
| 3409 | {std::tuple(StreamConfig(16000, 2), /*expect_error=*/false), |
| 3410 | std::tuple(StreamConfig(8000, 1), /*expect_error=*/false), |
| 3411 | std::tuple(StreamConfig(384000, 1), /*expect_error=*/false), |
| 3412 | std::tuple(StreamConfig(7900, 1), /*expect_error=*/true), |
| 3413 | std::tuple(StreamConfig(390000, 1), /*expect_error=*/true), |
| 3414 | std::tuple(StreamConfig(16000, 0), /*expect_error=*/true), |
| 3415 | std::tuple(StreamConfig(-16000, 0), /*expect_error=*/true)}) { |
| 3416 | SCOPED_TRACE(::testing::Message() |
| 3417 | << "sample_rate_hz=" << input_config.sample_rate_hz() |
| 3418 | << " num_channels=" << input_config.num_channels()); |
| 3419 | |
| 3420 | // Set up input data. |
| 3421 | ChannelBuffer<float> input_block( |
| 3422 | std::abs(input_config.sample_rate_hz()) / 100, |
| 3423 | input_config.num_channels()); |
| 3424 | |
| 3425 | // Call APM. |
| 3426 | rtc::scoped_refptr<AudioProcessing> ap = |
| 3427 | AudioProcessingBuilderForTesting().Create(); |
| 3428 | int error = ap->AnalyzeReverseStream(input_block.channels(), input_config); |
| 3429 | |
| 3430 | // Check output. |
| 3431 | if (expect_error) { |
| 3432 | EXPECT_NE(error, AudioProcessing::kNoError); |
| 3433 | } else { |
| 3434 | EXPECT_EQ(error, AudioProcessing::kNoError); |
| 3435 | } |
| 3436 | } |
| 3437 | } |
| 3438 | |
andrew@webrtc.org | 27c6980 | 2014-02-18 20:24:56 | [diff] [blame] | 3439 | } // namespace webrtc |