summaryrefslogtreecommitdiff
path: root/chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc')
-rw-r--r--chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc351
1 files changed, 299 insertions, 52 deletions
diff --git a/chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc b/chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc
index a552b77939c..63f34ecd60f 100644
--- a/chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc
+++ b/chromium/third_party/blink/renderer/platform/mediastream/media_stream_audio_processor_options_test.cc
@@ -24,17 +24,17 @@ constexpr WebRtcHybridAgcParams kHybridAgcParams{
.avx2_allowed = true,
.neon_allowed = true};
-constexpr AudioProcessingProperties kAudioProcessingNoAgc{
- .goog_auto_gain_control = false,
- .goog_experimental_auto_gain_control = false};
+constexpr media::AudioProcessingSettings kAudioProcessingNoAgc{
+ .automatic_gain_control = false,
+ .experimental_automatic_gain_control = false};
-constexpr AudioProcessingProperties kAudioProcessingNoExperimentalAgc{
- .goog_auto_gain_control = true,
- .goog_experimental_auto_gain_control = false};
+constexpr media::AudioProcessingSettings kAudioProcessingNoExperimentalAgc{
+ .automatic_gain_control = true,
+ .experimental_automatic_gain_control = false};
-constexpr AudioProcessingProperties kAudioProcessingExperimentalAgc{
- .goog_auto_gain_control = true,
- .goog_experimental_auto_gain_control = true};
+constexpr media::AudioProcessingSettings kAudioProcessingExperimentalAgc{
+ .automatic_gain_control = true,
+ .experimental_automatic_gain_control = true};
constexpr double kCompressionGainDb = 10.0;
@@ -47,7 +47,8 @@ constexpr WebRtcAnalogAgcClippingControlParams kClippingControlParams{
.crest_factor_margin = 5.55f,
.clipped_level_step = 666,
.clipped_ratio_threshold = 0.777f,
- .clipped_wait_frames = 300};
+ .clipped_wait_frames = 300,
+ .use_predicted_step = true};
} // namespace
TEST(ConfigAutomaticGainControlTest, DoNotChangeApmConfig) {
@@ -68,20 +69,6 @@ TEST(ConfigAutomaticGainControlTest, DoNotChangeApmConfig) {
EXPECT_EQ(apm_config.gain_controller2, kDefaultConfig.gain_controller2);
}
-TEST(ConfigAutomaticGainControlTest, SystemAgcDeactivatesBrowserAgcs) {
- webrtc::AudioProcessing::Config apm_config;
- constexpr AudioProcessingProperties kProperties{
- .system_gain_control_activated = true,
- .goog_auto_gain_control = true,
- .goog_experimental_auto_gain_control = true};
-
- ConfigAutomaticGainControl(kProperties, kHybridAgcParams,
- kClippingControlParams,
- /*compression_gain_db=*/10.0, apm_config);
- EXPECT_FALSE(apm_config.gain_controller1.enabled);
- EXPECT_FALSE(apm_config.gain_controller2.enabled);
-}
-
TEST(ConfigAutomaticGainControlTest, EnableDefaultAGC1) {
webrtc::AudioProcessing::Config apm_config;
@@ -187,15 +174,17 @@ TEST(ConfigAutomaticGainControlTest, EnableClippingControl) {
kClippingControlParams.clipping_threshold);
EXPECT_FLOAT_EQ(clipping_predictor.crest_factor_margin,
kClippingControlParams.crest_factor_margin);
+ EXPECT_EQ(clipping_predictor.use_predicted_step,
+ kClippingControlParams.use_predicted_step);
}
TEST(PopulateApmConfigTest, DefaultWithoutConfigJson) {
webrtc::AudioProcessing::Config apm_config;
- const AudioProcessingProperties properties;
+ const media::AudioProcessingSettings settings;
absl::optional<double> gain_control_compression_gain_db;
- PopulateApmConfig(&apm_config, properties,
- absl::nullopt, // |audio_processing_platform_config_json|.
+ PopulateApmConfig(&apm_config, settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
&gain_control_compression_gain_db);
EXPECT_FALSE(gain_control_compression_gain_db.has_value());
EXPECT_TRUE(apm_config.high_pass_filter.enabled);
@@ -214,13 +203,13 @@ TEST(PopulateApmConfigTest, DefaultWithoutConfigJson) {
TEST(PopulateApmConfigTest, SetGainsInConfigJson) {
webrtc::AudioProcessing::Config apm_config;
- const AudioProcessingProperties properties;
+ const media::AudioProcessingSettings settings;
absl::optional<std::string> audio_processing_platform_config_json =
"{\"gain_control_compression_gain_db\": 10, "
"\"pre_amplifier_fixed_gain_factor\": 2.0}";
absl::optional<double> gain_control_compression_gain_db;
- PopulateApmConfig(&apm_config, properties,
+ PopulateApmConfig(&apm_config, settings,
audio_processing_platform_config_json,
&gain_control_compression_gain_db);
EXPECT_TRUE(gain_control_compression_gain_db.has_value());
@@ -242,12 +231,12 @@ TEST(PopulateApmConfigTest, SetGainsInConfigJson) {
TEST(PopulateApmConfigTest, SetNoiseSuppressionLevelInConfigJson) {
webrtc::AudioProcessing::Config apm_config;
- const AudioProcessingProperties properties;
+ const media::AudioProcessingSettings settings;
absl::optional<std::string> audio_processing_platform_config_json =
"{\"noise_suppression_level\": 3}";
absl::optional<double> gain_control_compression_gain_db;
- PopulateApmConfig(&apm_config, properties,
+ PopulateApmConfig(&apm_config, settings,
audio_processing_platform_config_json,
&gain_control_compression_gain_db);
EXPECT_FALSE(gain_control_compression_gain_db.has_value());
@@ -265,28 +254,286 @@ TEST(PopulateApmConfigTest, SetNoiseSuppressionLevelInConfigJson) {
apm_config.echo_canceller.mobile_mode);
}
-TEST(PopulateApmConfigTest, SystemNsDeactivatesBrowserNs) {
- absl::optional<double> gain_control_compression_gain_db;
+TEST(CreateWebRtcAudioProcessingModuleTest, SetGainsInConfigJson) {
+ const media::AudioProcessingSettings settings{
+ .automatic_gain_control = true,
+ .experimental_automatic_gain_control = false};
+ absl::optional<std::string> audio_processing_platform_config_json =
+ "{\"gain_control_compression_gain_db\": 12.1212, "
+ "\"pre_amplifier_fixed_gain_factor\": 2.345}";
+
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings, audio_processing_platform_config_json,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ // Pre-amplifier is enabled if a gain factor is specified.
+ EXPECT_TRUE(config.pre_amplifier.enabled);
+ EXPECT_FLOAT_EQ(config.pre_amplifier.fixed_gain_factor, 2.345);
+
+ // Fixed digital AGC2 is enabled if AGC is on, analog AGC is off, and a
+ // compression gain is specified.
+ EXPECT_TRUE(config.gain_controller2.enabled);
+ EXPECT_FALSE(config.gain_controller2.adaptive_digital.enabled);
+ EXPECT_FLOAT_EQ(config.gain_controller2.fixed_digital.gain_db, 12.1212);
+}
- // Verify that the default value of `noise_suppression.enabled`
- // is true, since otherwise this test does not work.
- AudioProcessingProperties properties_without_system_ns;
- properties_without_system_ns.system_noise_suppression_activated = false;
- webrtc::AudioProcessing::Config apm_config_without_system_ns;
- PopulateApmConfig(&apm_config_without_system_ns, properties_without_system_ns,
- /*audio_processing_platform_config_json=*/absl::nullopt,
- &gain_control_compression_gain_db);
- EXPECT_TRUE(apm_config_without_system_ns.noise_suppression.enabled);
-
- // Verify that the presence of a system noise suppressor deactivates the
- // browser counterpart.
- AudioProcessingProperties properties_with_system_ns;
- properties_with_system_ns.system_noise_suppression_activated = true;
- webrtc::AudioProcessing::Config apm_config_with_system_ns;
- PopulateApmConfig(&apm_config_with_system_ns, properties_with_system_ns,
- /*audio_processing_platform_config_json=*/absl::nullopt,
- &gain_control_compression_gain_db);
- EXPECT_FALSE(apm_config_with_system_ns.noise_suppression.enabled);
+TEST(CreateWebRtcAudioProcessingModuleTest,
+ SetNoiseSuppressionLevelInConfigJson) {
+ const media::AudioProcessingSettings settings{.noise_suppression = true};
+ absl::optional<std::string> audio_processing_platform_config_json =
+ "{\"noise_suppression_level\": 3}";
+
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings, audio_processing_platform_config_json,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ EXPECT_TRUE(config.noise_suppression.enabled);
+ EXPECT_EQ(config.noise_suppression.level,
+ webrtc::AudioProcessing::Config::NoiseSuppression::kVeryHigh);
+}
+
+// Verify the default audio processing effects.
+TEST(CreateWebRtcAudioProcessingModuleTest, VerifyDefaultProperties) {
+ const AudioProcessingProperties properties;
+ const media::AudioProcessingSettings settings =
+ properties.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ EXPECT_TRUE(config.pipeline.multi_channel_render);
+ EXPECT_TRUE(config.pipeline.multi_channel_capture);
+ EXPECT_EQ(config.pipeline.maximum_internal_processing_rate, 48000);
+ EXPECT_TRUE(config.high_pass_filter.enabled);
+ EXPECT_TRUE(config.echo_canceller.enabled);
+ EXPECT_TRUE(config.gain_controller1.enabled);
+ EXPECT_TRUE(config.gain_controller1.analog_gain_controller.enabled);
+ EXPECT_FALSE(config.gain_controller2.enabled);
+ EXPECT_TRUE(config.noise_suppression.enabled);
+ EXPECT_FALSE(config.voice_detection.enabled);
+ EXPECT_FALSE(config.residual_echo_detector.enabled);
+
+#if defined(OS_ANDROID)
+ // Android uses echo cancellation optimized for mobiles, and does not
+ // support keytap suppression.
+ EXPECT_TRUE(config.echo_canceller.mobile_mode);
+ EXPECT_FALSE(config.transient_suppression.enabled);
+#else
+ EXPECT_FALSE(config.echo_canceller.mobile_mode);
+ EXPECT_TRUE(config.transient_suppression.enabled);
+#endif
+}
+
+TEST(CreateWebRtcAudioProcessingModuleTest, VerifyNoiseSuppressionSettings) {
+ for (bool ns_enabled : {true, false}) {
+ const media::AudioProcessingSettings settings{.noise_suppression =
+ ns_enabled};
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ EXPECT_EQ(config.noise_suppression.enabled, ns_enabled);
+ EXPECT_EQ(config.noise_suppression.level,
+ webrtc::AudioProcessing::Config::NoiseSuppression::kHigh);
+ }
+}
+
+TEST(CreateWebRtcAudioProcessingModuleTest, VerifyEchoCancellerSettings) {
+ for (bool ec_enabled : {true, false}) {
+ const media::AudioProcessingSettings settings{.echo_cancellation =
+ ec_enabled};
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ EXPECT_EQ(config.echo_canceller.enabled, ec_enabled);
+#if defined(OS_ANDROID)
+ EXPECT_TRUE(config.echo_canceller.mobile_mode);
+#else
+ EXPECT_FALSE(config.echo_canceller.mobile_mode);
+#endif
+ }
+}
+
+TEST(CreateWebRtcAudioProcessingModuleTest, ToggleHighPassFilter) {
+ for (bool high_pass_filter_enabled : {true, false}) {
+ const media::AudioProcessingSettings settings{.high_pass_filter =
+ high_pass_filter_enabled};
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+ EXPECT_EQ(config.high_pass_filter.enabled, high_pass_filter_enabled);
+ }
+}
+
+TEST(CreateWebRtcAudioProcessingModuleTest, ToggleTransientSuppression) {
+ for (bool transient_suppression_enabled : {true, false}) {
+ const media::AudioProcessingSettings settings{
+ .transient_noise_suppression = transient_suppression_enabled};
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings,
+ /*audio_processing_platform_config_json=*/absl::nullopt,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+
+#if !defined(OS_IOS) && !defined(OS_ANDROID)
+ EXPECT_EQ(config.transient_suppression.enabled,
+ transient_suppression_enabled);
+#else
+ // Transient suppression is not supported (nor useful) on mobile platforms.
+ EXPECT_FALSE(config.transient_suppression.enabled);
+#endif
+ }
+}
+
+// There is no way to test what echo cancellation configuration is applied, but
+// this test at least exercises the code that handles echo cancellation
+// configuration from JSON.
+TEST(CreateWebRtcAudioProcessingModuleTest,
+ ApplyEchoCancellationConfigFromJson) {
+ // Arbitrary settings to have something to parse.
+ absl::optional<std::string> audio_processing_platform_config_json =
+ "{\"aec3\": {"
+ "\"comfort_noise\": {\"noise_floor_dbfs\": -123.4567},"
+ "\"echo_model\": {\"min_noise_floor_power\": 1234567.8},"
+ "},}";
+ const media::AudioProcessingSettings settings{.echo_cancellation = true};
+ rtc::scoped_refptr<webrtc::AudioProcessing> apm =
+ CreateWebRtcAudioProcessingModule(
+ settings, audio_processing_platform_config_json,
+ /*agc_startup_min_volume=*/absl::nullopt);
+ ASSERT_TRUE(!!apm);
+ webrtc::AudioProcessing::Config config = apm->GetConfig();
+ EXPECT_TRUE(config.echo_canceller.enabled);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ DefaultPropertiesAndSettingsMatch) {
+ const media::AudioProcessingSettings default_settings;
+ AudioProcessingProperties properties;
+ const media::AudioProcessingSettings generated_settings =
+ properties.ToAudioProcessingSettings(
+ default_settings.multi_channel_capture_processing);
+ EXPECT_EQ(default_settings, generated_settings);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ DisableDefaultProperties) {
+ AudioProcessingProperties properties;
+ properties.DisableDefaultProperties();
+ const media::AudioProcessingSettings settings =
+ properties.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_FALSE(settings.echo_cancellation);
+ EXPECT_FALSE(settings.noise_suppression);
+ EXPECT_FALSE(settings.transient_noise_suppression);
+ EXPECT_FALSE(settings.automatic_gain_control);
+ EXPECT_FALSE(settings.experimental_automatic_gain_control);
+ EXPECT_FALSE(settings.high_pass_filter);
+ EXPECT_FALSE(settings.stereo_mirroring);
+ EXPECT_FALSE(settings.force_apm_creation);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ AllBrowserPropertiesEnabled) {
+ const AudioProcessingProperties properties{
+ .echo_cancellation_type = AudioProcessingProperties::
+ EchoCancellationType::kEchoCancellationAec3,
+ .goog_audio_mirroring = true,
+ .goog_auto_gain_control = true,
+ .goog_experimental_echo_cancellation = true,
+ .goog_noise_suppression = true,
+ .goog_experimental_noise_suppression = true,
+ .goog_highpass_filter = true,
+ .goog_experimental_auto_gain_control = true};
+ const media::AudioProcessingSettings settings =
+ properties.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_TRUE(settings.echo_cancellation);
+ EXPECT_TRUE(settings.noise_suppression);
+ EXPECT_TRUE(settings.transient_noise_suppression);
+ EXPECT_TRUE(settings.automatic_gain_control);
+ EXPECT_TRUE(settings.experimental_automatic_gain_control);
+ EXPECT_TRUE(settings.high_pass_filter);
+ EXPECT_TRUE(settings.stereo_mirroring);
+ EXPECT_TRUE(settings.force_apm_creation);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ SystemAecDisablesBrowserAec) {
+ AudioProcessingProperties properties{
+ .echo_cancellation_type = AudioProcessingProperties::
+ EchoCancellationType::kEchoCancellationSystem};
+ media::AudioProcessingSettings settings =
+ properties.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_FALSE(settings.echo_cancellation);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ SystemNsDeactivatesBrowserNs) {
+ // Verify that noise suppression is by default enabled, since otherwise this
+ // test does not work.
+ constexpr AudioProcessingProperties kPropertiesWithoutSystemNs{
+ .system_noise_suppression_activated = false};
+ media::AudioProcessingSettings settings_without_system_ns =
+ kPropertiesWithoutSystemNs.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_TRUE(settings_without_system_ns.noise_suppression);
+
+ constexpr AudioProcessingProperties kPropertiesWithSystemNs{
+ .system_noise_suppression_activated = true};
+ media::AudioProcessingSettings settings_with_system_ns =
+ kPropertiesWithSystemNs.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_FALSE(settings_with_system_ns.noise_suppression);
+}
+
+TEST(AudioProcessingPropertiesToAudioProcessingSettingsTest,
+ SystemAgcDeactivatesBrowserAgc) {
+ // Verify that gain control is by default enabled, since otherwise this test
+ // does not work.
+ constexpr AudioProcessingProperties kPropertiesWithoutSystemAgc{
+ .system_gain_control_activated = false};
+ media::AudioProcessingSettings settings_without_system_agc =
+ kPropertiesWithoutSystemAgc.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_TRUE(settings_without_system_agc.automatic_gain_control);
+
+ constexpr AudioProcessingProperties kPropertiesWithSystemAgc{
+ .system_gain_control_activated = true};
+ media::AudioProcessingSettings settings_with_system_agc =
+ kPropertiesWithSystemAgc.ToAudioProcessingSettings(
+ /*multi_channel_capture_processing=*/true);
+ EXPECT_FALSE(settings_with_system_agc.automatic_gain_control);
}
} // namespace blink
View Lorry Controller Status