admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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}
This commit is contained in:
Danil Chapovalov 2024-11-04 15:45:01 +01:00 committed by WebRTC LUCI CQ
parent 3bd3815c4d
commit 1a93080b8d
6 changed files with 106 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sdk/BUILD.gn
View File

@ -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",

13
sdk/objc/api/peerconnection/RTCPeerConnectionFactory+Native.h
View File

@ -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

131
sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm
View File

@ -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
initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
nativeVideoEncoderFactory:webrtc::ObjCToNativeVideoEncoderFactory([[RTC_OBJC_TYPE(
RTCVideoEncoderFactoryH264) alloc] init])
nativeVideoDecoderFactory:webrtc::ObjCToNativeVideoDecoderFactory([[RTC_OBJC_TYPE(
RTCVideoDecoderFactoryH264) alloc] init])
audioDeviceModule:[self audioDeviceModule].get()
audioProcessingModule:nullptr];
webrtc::PeerConnectionFactoryDependencies dependencies;
dependencies.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
dependencies.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
dependencies.video_encoder_factory = webrtc::ObjCToNativeVideoEncoderFactory(
[[RTC_OBJC_TYPE(RTCVideoEncoderFactoryH264) alloc] init]);
dependencies.video_decoder_factory = webrtc::ObjCToNativeVideoDecoderFactory(
[[RTC_OBJC_TYPE(RTCVideoDecoderFactoryH264) alloc] init]);
dependencies.adm = [self audioDeviceModule];
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;
std::unique_ptr<webrtc::VideoDecoderFactory> native_decoder_factory;
webrtc::PeerConnectionFactoryDependencies dependencies;
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()
nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
nativeVideoEncoderFactory:std::move(native_encoder_factory)
nativeVideoDecoderFactory:std::move(native_decoder_factory)
audioDeviceModule:audio_device_module.get()
audioProcessingModule:nullptr];
return [self initWithMediaAndDependencies:std::move(dependencies)];
#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];
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;
return [self initWithNativeDependencies:webrtc::PeerConnectionFactoryDependencies()];
}
- (instancetype)initWithNativeAudioEncoderFactory:
@ -166,14 +164,18 @@
audioDeviceModule:(webrtc::AudioDeviceModule *)audioDeviceModule
audioProcessingModule:
(rtc::scoped_refptr<webrtc::AudioProcessing>)audioProcessingModule {
return [self initWithNativeAudioEncoderFactory:audioEncoderFactory
nativeAudioDecoderFactory:audioDecoderFactory
nativeVideoEncoderFactory:std::move(videoEncoderFactory)
nativeVideoDecoderFactory:std::move(videoDecoderFactory)
audioDeviceModule:audioDeviceModule
audioProcessingModule:audioProcessingModule
networkControllerFactory:nullptr];
webrtc::PeerConnectionFactoryDependencies dependencies;
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);
dependencies.adm = std::move(audioDeviceModule);
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) {
dependencies.audio_processing = std::move(audioProcessingModule);
} else {
dependencies.audio_processing = webrtc::AudioProcessingBuilder().Create();
if (audioProcessingModule != nullptr) {
dependencies.audio_processing_builder = CustomAudioProcessing(std::move(audioProcessingModule));
}
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>();
dependencies.network_controller_factory = std::move(networkControllerFactory);
_nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
}
return self;
return [self initWithNativeDependencies:std::move(dependencies)];
}
- (RTC_OBJC_TYPE(RTCRtpCapabilities) *)rtpSenderCapabilitiesForKind:(NSString *)kind {

6
sdk/objc/api/peerconnection/RTCPeerConnectionFactoryBuilder.h
View File

@ -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

38
sdk/objc/api/peerconnection/RTCPeerConnectionFactoryBuilder.mm
View File

@ -19,12 +19,7 @@
#include "api/video_codecs/video_encoder_factory.h"
@implementation RTCPeerConnectionFactoryBuilder {
std::unique_ptr<webrtc::VideoEncoderFactory> _videoEncoderFactory;
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;
webrtc::PeerConnectionFactoryDependencies _dependencies;
}
+ (RTCPeerConnectionFactoryBuilder *)builder {
@ -32,41 +27,44 @@
}
- (RTC_OBJC_TYPE(RTCPeerConnectionFactory) *)createPeerConnectionFactory {
RTC_OBJC_TYPE(RTCPeerConnectionFactory) *factory =
[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc];
return [factory initWithNativeAudioEncoderFactory:_audioEncoderFactory
nativeAudioDecoderFactory:_audioDecoderFactory
nativeVideoEncoderFactory:std::move(_videoEncoderFactory)
nativeVideoDecoderFactory:std::move(_videoDecoderFactory)
audioDeviceModule:_audioDeviceModule.get()
audioProcessingModule:_audioProcessingModule];
return [[RTC_OBJC_TYPE(RTCPeerConnectionFactory) alloc]
initWithMediaAndDependencies:std::move(_dependencies)];
}
- (void)setFieldTrials:(std::unique_ptr<webrtc::FieldTrialsView>)fieldTrials {
_dependencies.trials = std::move(fieldTrials);
}
- (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

14
sdk/objc/unittests/RTCPeerConnectionFactoryBuilderTest.mm
View File

@ -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
nativeAudioDecoderFactory:nullptr
nativeVideoEncoderFactory:nullptr
nativeVideoDecoderFactory:nullptr
audioDeviceModule:nullptr
audioProcessingModule:nullptr]);
initWithMediaAndDependencies:webrtc::PeerConnectionFactoryDependencies()]);
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
nativeAudioDecoderFactory:nullptr
nativeVideoEncoderFactory:nullptr
nativeVideoDecoderFactory:nullptr
audioDeviceModule:nullptr
audioProcessingModule:nullptr]);
initWithMediaAndDependencies:webrtc::PeerConnectionFactoryDependencies()]);
RTCPeerConnectionFactoryBuilder* builder = [RTCPeerConnectionFactoryBuilder defaultBuilder];
RTC_OBJC_TYPE(RTCPeerConnectionFactory)* peerConnectionFactory =
[builder createPeerConnectionFactory];