Extend ios RTCPeerConnectionFactoryBuilder to have custom audio processing builder and field trials

Bug: webrtc:369904700
Change-Id: I1f2914b231d16948e571d8967a38f62080538fe0
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/367020
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43358}

sdk/BUILD.gn

@@ -1066,6 +1066,7 @@ if (is_ios || is_mac) {
         ":videotoolbox_objc",
         "../api:dtmf_sender_interface",
         "../api:enable_media",
+        "../api:field_trials_view",
         "../api:libjingle_peerconnection_api",
         "../api:media_stream_interface",
         "../api:rtc_event_log_output_file",
@@ -1075,6 +1076,7 @@ if (is_ios || is_mac) {
         "../api:scoped_refptr",
         "../api/audio:audio_device",
         "../api/audio:audio_processing",
+        "../api/audio:builtin_audio_processing_builder",
         "../api/audio_codecs:audio_codecs_api",
         "../api/audio_codecs:builtin_audio_decoder_factory",
         "../api/audio_codecs:builtin_audio_encoder_factory",
@@ -1091,7 +1093,6 @@ if (is_ios || is_mac) {
         "../common_video",
         "../media:media_constants",
         "../media:rtc_media_base",
-        "../modules/audio_processing",
         "../modules/video_coding:video_codec_interface",
         "../pc:peer_connection_factory",
         "../pc:webrtc_sdp",

sdk/objc/api/peerconnection/RTCPeerConnectionFactory+Native.h

@@ -14,17 +14,12 @@
 #include "api/audio/audio_processing.h"
 #include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/peer_connection_interface.h"
 #include "api/scoped_refptr.h"
 #include "api/transport/network_control.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
 
-namespace webrtc {
-
-struct PeerConnectionDependencies;
-
-}  // namespace webrtc
-
 NS_ASSUME_NONNULL_BEGIN
 
 /**
@@ -33,11 +28,13 @@ NS_ASSUME_NONNULL_BEGIN
 @interface RTC_OBJC_TYPE (RTCPeerConnectionFactory)
 ()
 
-    - (instancetype)initNative NS_DESIGNATED_INITIALIZER;
-
 /* Initializer used when WebRTC is compiled with no media support */
 - (instancetype)initWithNoMedia;
 
+/* Initialize object with provided dependencies and with media support. */
+- (instancetype)initWithMediaAndDependencies:
+    (webrtc::PeerConnectionFactoryDependencies)dependencies;
+
 /* Initialize object with injectable native audio/video encoder/decoder factories */
 - (instancetype)initWithNativeAudioEncoderFactory:
                     (rtc::scoped_refptr<webrtc::AudioEncoderFactory>)audioEncoderFactory

sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm

@@ -29,10 +29,10 @@
 #include "rtc_base/checks.h"
 #include "sdk/objc/native/api/network_monitor_factory.h"
 #include "sdk/objc/native/api/ssl_certificate_verifier.h"
-#include "system_wrappers/include/field_trial.h"
 
 #include "api/audio/audio_device.h"
 #include "api/audio/audio_processing.h"
+#include "api/audio/builtin_audio_processing_builder.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/enable_media.h"
@@ -71,15 +71,15 @@
 }
 
 - (instancetype)init {
-  return [self
+  webrtc::PeerConnectionFactoryDependencies dependencies;
-      initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
+  dependencies.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
-              nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
+  dependencies.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
-              nativeVideoEncoderFactory:webrtc::ObjCToNativeVideoEncoderFactory([[RTC_OBJC_TYPE(
+  dependencies.video_encoder_factory = webrtc::ObjCToNativeVideoEncoderFactory(
-                                            RTCVideoEncoderFactoryH264) alloc] init])
+      [[RTC_OBJC_TYPE(RTCVideoEncoderFactoryH264) alloc] init]);
-              nativeVideoDecoderFactory:webrtc::ObjCToNativeVideoDecoderFactory([[RTC_OBJC_TYPE(
+  dependencies.video_decoder_factory = webrtc::ObjCToNativeVideoDecoderFactory(
-                                            RTCVideoDecoderFactoryH264) alloc] init])
+      [[RTC_OBJC_TYPE(RTCVideoDecoderFactoryH264) alloc] init]);
-                      audioDeviceModule:[self audioDeviceModule].get()
+  dependencies.adm = [self audioDeviceModule];
-                  audioProcessingModule:nullptr];
+  return [self initWithMediaAndDependencies:std::move(dependencies)];
 }
 
 - (instancetype)
@@ -95,30 +95,25 @@
 #ifdef HAVE_NO_MEDIA
   return [self initWithNoMedia];
 #else
-  std::unique_ptr<webrtc::VideoEncoderFactory> native_encoder_factory;
+  webrtc::PeerConnectionFactoryDependencies dependencies;
-  std::unique_ptr<webrtc::VideoDecoderFactory> native_decoder_factory;
+  dependencies.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
+  dependencies.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
   if (encoderFactory) {
-    native_encoder_factory = webrtc::ObjCToNativeVideoEncoderFactory(encoderFactory);
+    dependencies.video_encoder_factory = webrtc::ObjCToNativeVideoEncoderFactory(encoderFactory);
   }
   if (decoderFactory) {
-    native_decoder_factory = webrtc::ObjCToNativeVideoDecoderFactory(decoderFactory);
+    dependencies.video_decoder_factory = webrtc::ObjCToNativeVideoDecoderFactory(decoderFactory);
   }
-  rtc::scoped_refptr<webrtc::AudioDeviceModule> audio_device_module;
   if (audioDevice) {
-    audio_device_module = webrtc::CreateAudioDeviceModule(audioDevice);
+    dependencies.adm = webrtc::CreateAudioDeviceModule(audioDevice);
   } else {
-    audio_device_module = [self audioDeviceModule];
+    dependencies.adm = [self audioDeviceModule];
   }
-  return [self initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
+  return [self initWithMediaAndDependencies:std::move(dependencies)];
-                       nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
-                       nativeVideoEncoderFactory:std::move(native_encoder_factory)
-                       nativeVideoDecoderFactory:std::move(native_decoder_factory)
-                               audioDeviceModule:audio_device_module.get()
-                           audioProcessingModule:nullptr];
 #endif
 }
 
-- (instancetype)initNative {
+- (instancetype)initWithNativeDependencies:(webrtc::PeerConnectionFactoryDependencies)dependencies {
   self = [super init];
   if (self) {
     _networkThread = rtc::Thread::CreateWithSocketServer();
@@ -135,24 +130,27 @@
     _signalingThread->SetName("signaling_thread", _signalingThread.get());
     result = _signalingThread->Start();
     RTC_DCHECK(result) << "Failed to start signaling thread.";
+
+    // Set fields that are relevant both to 'no media' and 'with media' scenarios.
+    dependencies.network_thread = _networkThread.get();
+    dependencies.worker_thread = _workerThread.get();
+    dependencies.signaling_thread = _signalingThread.get();
+    if (dependencies.trials == nullptr) {
+      dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
+    }
+    if (dependencies.network_monitor_factory == nullptr &&
+        dependencies.trials->IsEnabled("WebRTC-Network-UseNWPathMonitor")) {
+      dependencies.network_monitor_factory = webrtc::CreateNetworkMonitorFactory();
+    }
+
+    _nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
+    NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
   }
   return self;
 }
 
 - (instancetype)initWithNoMedia {
-  self = [self initNative];
+  return [self initWithNativeDependencies:webrtc::PeerConnectionFactoryDependencies()];
-  if (self) {
-    webrtc::PeerConnectionFactoryDependencies dependencies;
-    dependencies.network_thread = _networkThread.get();
-    dependencies.worker_thread = _workerThread.get();
-    dependencies.signaling_thread = _signalingThread.get();
-    if (webrtc::field_trial::IsEnabled("WebRTC-Network-UseNWPathMonitor")) {
-      dependencies.network_monitor_factory = webrtc::CreateNetworkMonitorFactory();
-    }
-    _nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
-    NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
-  }
-  return self;
 }
 
 - (instancetype)initWithNativeAudioEncoderFactory:
@@ -166,14 +164,18 @@
                                 audioDeviceModule:(webrtc::AudioDeviceModule *)audioDeviceModule
                             audioProcessingModule:
                                 (rtc::scoped_refptr<webrtc::AudioProcessing>)audioProcessingModule {
-  return [self initWithNativeAudioEncoderFactory:audioEncoderFactory
+  webrtc::PeerConnectionFactoryDependencies dependencies;
-                       nativeAudioDecoderFactory:audioDecoderFactory
+  dependencies.audio_encoder_factory = std::move(audioEncoderFactory);
-                       nativeVideoEncoderFactory:std::move(videoEncoderFactory)
+  dependencies.audio_decoder_factory = std::move(audioDecoderFactory);
-                       nativeVideoDecoderFactory:std::move(videoDecoderFactory)
+  dependencies.video_encoder_factory = std::move(videoEncoderFactory);
-                               audioDeviceModule:audioDeviceModule
+  dependencies.video_decoder_factory = std::move(videoDecoderFactory);
-                           audioProcessingModule:audioProcessingModule
+  dependencies.adm = std::move(audioDeviceModule);
-                        networkControllerFactory:nullptr];
+  if (audioProcessingModule != nullptr) {
+    dependencies.audio_processing_builder = CustomAudioProcessing(std::move(audioProcessingModule));
+  }
+  return [self initWithMediaAndDependencies:std::move(dependencies)];
 }
+
 - (instancetype)initWithNativeAudioEncoderFactory:
                     (rtc::scoped_refptr<webrtc::AudioEncoderFactory>)audioEncoderFactory
                         nativeAudioDecoderFactory:
@@ -188,35 +190,34 @@
                          networkControllerFactory:
                              (std::unique_ptr<webrtc::NetworkControllerFactoryInterface>)
                                  networkControllerFactory {
-  self = [self initNative];
-  if (self) {
   webrtc::PeerConnectionFactoryDependencies dependencies;
-    dependencies.network_thread = _networkThread.get();
-    dependencies.worker_thread = _workerThread.get();
-    dependencies.signaling_thread = _signalingThread.get();
-    if (webrtc::field_trial::IsEnabled("WebRTC-Network-UseNWPathMonitor")) {
-      dependencies.network_monitor_factory = webrtc::CreateNetworkMonitorFactory();
-    }
-    dependencies.trials = std::make_unique<webrtc::FieldTrialBasedConfig>();
-    dependencies.task_queue_factory =
-        webrtc::CreateDefaultTaskQueueFactory(dependencies.trials.get());
   dependencies.adm = std::move(audioDeviceModule);
   dependencies.audio_encoder_factory = std::move(audioEncoderFactory);
   dependencies.audio_decoder_factory = std::move(audioDecoderFactory);
   dependencies.video_encoder_factory = std::move(videoEncoderFactory);
   dependencies.video_decoder_factory = std::move(videoDecoderFactory);
-    if (audioProcessingModule) {
+  if (audioProcessingModule != nullptr) {
-      dependencies.audio_processing = std::move(audioProcessingModule);
+    dependencies.audio_processing_builder = CustomAudioProcessing(std::move(audioProcessingModule));
-    } else {
+  }
-      dependencies.audio_processing = webrtc::AudioProcessingBuilder().Create();
+  dependencies.network_controller_factory = std::move(networkControllerFactory);
+  return [self initWithMediaAndDependencies:std::move(dependencies)];
+}
+
+- (instancetype)initWithMediaAndDependencies:
+    (webrtc::PeerConnectionFactoryDependencies)dependencies {
+  // audio_processing_builder should be used instead in new code.
+  RTC_CHECK(dependencies.audio_processing == nullptr);
+#ifndef WEBRTC_EXCLUDE_AUDIO_PROCESSING_MODULE
+  if (dependencies.audio_processing_builder == nullptr) {
+    dependencies.audio_processing_builder =
+        std::make_unique<webrtc::BuiltinAudioProcessingBuilder>();
+  }
+#endif
+  if (dependencies.event_log_factory == nullptr) {
+    dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>();
   }
   webrtc::EnableMedia(dependencies);
-    dependencies.event_log_factory = std::make_unique<webrtc::RtcEventLogFactory>();
+  return [self initWithNativeDependencies:std::move(dependencies)];
-    dependencies.network_controller_factory = std::move(networkControllerFactory);
-    _nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
-    NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
-  }
-  return self;
 }
 
 - (RTC_OBJC_TYPE(RTCRtpCapabilities) *)rtpSenderCapabilitiesForKind:(NSString *)kind {

sdk/objc/api/peerconnection/RTCPeerConnectionFactoryBuilder.h

@@ -14,6 +14,7 @@
 #include "api/audio/audio_processing.h"
 #include "api/audio_codecs/audio_decoder_factory.h"
 #include "api/audio_codecs/audio_encoder_factory.h"
+#include "api/field_trials_view.h"
 #include "api/scoped_refptr.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
@@ -26,6 +27,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)createPeerConnectionFactory;
 
+- (void)setFieldTrials:(std::unique_ptr<webrtc::FieldTrialsView>)fieldTrials;
+
 - (void)setVideoEncoderFactory:(std::unique_ptr<webrtc::VideoEncoderFactory>)videoEncoderFactory;
 
 - (void)setVideoDecoderFactory:(std::unique_ptr<webrtc::VideoDecoderFactory>)videoDecoderFactory;
@@ -38,6 +41,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)setAudioProcessingModule:(rtc::scoped_refptr<webrtc::AudioProcessing>)audioProcessingModule;
 
+- (void)setAudioProcessingBuilder:
+    (std::unique_ptr<webrtc::AudioProcessingBuilderInterface>)audioProcessingBuilder;
+
 @end
 
 NS_ASSUME_NONNULL_END

sdk/objc/api/peerconnection/RTCPeerConnectionFactoryBuilder.mm

@@ -19,12 +19,7 @@
 #include "api/video_codecs/video_encoder_factory.h"
 
 @implementation RTCPeerConnectionFactoryBuilder {
-  std::unique_ptr<webrtc::VideoEncoderFactory> _videoEncoderFactory;
+  webrtc::PeerConnectionFactoryDependencies _dependencies;
-  std::unique_ptr<webrtc::VideoDecoderFactory> _videoDecoderFactory;
-  rtc::scoped_refptr<webrtc::AudioEncoderFactory> _audioEncoderFactory;
-  rtc::scoped_refptr<webrtc::AudioDecoderFactory> _audioDecoderFactory;
-  rtc::scoped_refptr<webrtc::AudioDeviceModule> _audioDeviceModule;
-  rtc::scoped_refptr<webrtc::AudioProcessing> _audioProcessingModule;
 }
 
 + (RTCPeerConnectionFactoryBuilder *)builder {
@@ -32,41 +27,44 @@
 }
 
 - (RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)createPeerConnectionFactory {
-  RTC_OBJC_TYPE(RTCPeerConnectionFactory) *factory =
+  return [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc]
-      [RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc];
+      initWithMediaAndDependencies:std::move(_dependencies)];
-  return [factory initWithNativeAudioEncoderFactory:_audioEncoderFactory
+}
-                          nativeAudioDecoderFactory:_audioDecoderFactory
+
-                          nativeVideoEncoderFactory:std::move(_videoEncoderFactory)
+- (void)setFieldTrials:(std::unique_ptr<webrtc::FieldTrialsView>)fieldTrials {
-                          nativeVideoDecoderFactory:std::move(_videoDecoderFactory)
+  _dependencies.trials = std::move(fieldTrials);
-                                  audioDeviceModule:_audioDeviceModule.get()
-                              audioProcessingModule:_audioProcessingModule];
 }
 
 - (void)setVideoEncoderFactory:(std::unique_ptr<webrtc::VideoEncoderFactory>)videoEncoderFactory {
-  _videoEncoderFactory = std::move(videoEncoderFactory);
+  _dependencies.video_encoder_factory = std::move(videoEncoderFactory);
 }
 
 - (void)setVideoDecoderFactory:(std::unique_ptr<webrtc::VideoDecoderFactory>)videoDecoderFactory {
-  _videoDecoderFactory = std::move(videoDecoderFactory);
+  _dependencies.video_decoder_factory = std::move(videoDecoderFactory);
 }
 
 - (void)setAudioEncoderFactory:
         (rtc::scoped_refptr<webrtc::AudioEncoderFactory>)audioEncoderFactory {
-  _audioEncoderFactory = audioEncoderFactory;
+  _dependencies.audio_encoder_factory = std::move(audioEncoderFactory);
 }
 
 - (void)setAudioDecoderFactory:
         (rtc::scoped_refptr<webrtc::AudioDecoderFactory>)audioDecoderFactory {
-  _audioDecoderFactory = audioDecoderFactory;
+  _dependencies.audio_decoder_factory = std::move(audioDecoderFactory);
 }
 
 - (void)setAudioDeviceModule:(rtc::scoped_refptr<webrtc::AudioDeviceModule>)audioDeviceModule {
-  _audioDeviceModule = audioDeviceModule;
+  _dependencies.adm = std::move(audioDeviceModule);
 }
 
 - (void)setAudioProcessingModule:
         (rtc::scoped_refptr<webrtc::AudioProcessing>)audioProcessingModule {
-  _audioProcessingModule = audioProcessingModule;
+  _dependencies.audio_processing_builder = CustomAudioProcessing(std::move(audioProcessingModule));
+}
+
+- (void)setAudioProcessingBuilder:
+    (std::unique_ptr<webrtc::AudioProcessingBuilderInterface>)audioProcessingBuilder {
+  _dependencies.audio_processing_builder = std::move(audioProcessingBuilder);
 }
 
 @end

sdk/objc/unittests/RTCPeerConnectionFactoryBuilderTest.mm

@@ -40,12 +40,7 @@ extern "C" {
   id factoryMock = OCMStrictClassMock([RTC_OBJC_TYPE(RTCPeerConnectionFactory) class]);
   OCMExpect([factoryMock alloc]).andReturn(factoryMock);
   RTC_UNUSED([[[[factoryMock expect] andReturn:factoryMock] ignoringNonObjectArgs]
-      initWithNativeAudioEncoderFactory:nullptr
+      initWithMediaAndDependencies:webrtc::PeerConnectionFactoryDependencies()]);
-              nativeAudioDecoderFactory:nullptr
-              nativeVideoEncoderFactory:nullptr
-              nativeVideoDecoderFactory:nullptr
-                      audioDeviceModule:nullptr
-                  audioProcessingModule:nullptr]);
   RTCPeerConnectionFactoryBuilder* builder = [[RTCPeerConnectionFactoryBuilder alloc] init];
   RTC_OBJC_TYPE(RTCPeerConnectionFactory)* peerConnectionFactory =
       [builder createPeerConnectionFactory];
@@ -57,12 +52,7 @@ extern "C" {
   id factoryMock = OCMStrictClassMock([RTC_OBJC_TYPE(RTCPeerConnectionFactory) class]);
   OCMExpect([factoryMock alloc]).andReturn(factoryMock);
   RTC_UNUSED([[[[factoryMock expect] andReturn:factoryMock] ignoringNonObjectArgs]
-      initWithNativeAudioEncoderFactory:nullptr
+      initWithMediaAndDependencies:webrtc::PeerConnectionFactoryDependencies()]);
-              nativeAudioDecoderFactory:nullptr
-              nativeVideoEncoderFactory:nullptr
-              nativeVideoDecoderFactory:nullptr
-                      audioDeviceModule:nullptr
-                  audioProcessingModule:nullptr]);
   RTCPeerConnectionFactoryBuilder* builder = [RTCPeerConnectionFactoryBuilder defaultBuilder];
   RTC_OBJC_TYPE(RTCPeerConnectionFactory)* peerConnectionFactory =
       [builder createPeerConnectionFactory];