mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-15 06:40:43 +01:00
dd8c16574e
This CL adds a GN build flag to include builtin software codecs (enabled by default). When setting the flag to false, libvpx can also be excluded. The benefit is that the resulting binary is smaller. Replaces https://webrtc-review.googlesource.com/c/src/+/29203 Bug: webrtc:7925 Change-Id: Id330ea8a43169e449ee139eca18e4557cc932e10 Reviewed-on: https://webrtc-review.googlesource.com/36340 Commit-Queue: Anders Carlsson <andersc@webrtc.org> Reviewed-by: Patrik Höglund <phoglund@webrtc.org> Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org> Reviewed-by: Erik Språng <sprang@webrtc.org> Reviewed-by: Magnus Jedvert <magjed@webrtc.org> Cr-Commit-Position: refs/heads/master@{#21818}
301 lines
13 KiB
Text
301 lines
13 KiB
Text
/*
|
|
* Copyright 2015 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#import "RTCPeerConnectionFactory+Native.h"
|
|
#import "RTCPeerConnectionFactory+Private.h"
|
|
#import "RTCPeerConnectionFactoryOptions+Private.h"
|
|
|
|
#import "NSString+StdString.h"
|
|
#import "RTCAVFoundationVideoSource+Private.h"
|
|
#import "RTCAudioSource+Private.h"
|
|
#import "RTCAudioTrack+Private.h"
|
|
#import "RTCMediaConstraints+Private.h"
|
|
#import "RTCMediaStream+Private.h"
|
|
#import "RTCPeerConnection+Private.h"
|
|
#import "RTCVideoSource+Private.h"
|
|
#import "RTCVideoTrack+Private.h"
|
|
#import "WebRTC/RTCLogging.h"
|
|
#import "WebRTC/RTCVideoCodecFactory.h"
|
|
#ifndef HAVE_NO_MEDIA
|
|
#include "VideoToolbox/objc_video_decoder_factory.h"
|
|
#include "VideoToolbox/objc_video_encoder_factory.h"
|
|
#import "WebRTC/RTCVideoCodecH264.h"
|
|
// The no-media version PeerConnectionFactory doesn't depend on these files, but the gn check tool
|
|
// is not smart enough to take the #ifdef into account.
|
|
#include "api/audio_codecs/builtin_audio_decoder_factory.h" // nogncheck
|
|
#include "api/audio_codecs/builtin_audio_encoder_factory.h" // nogncheck
|
|
#include "media/engine/convert_legacy_video_factory.h" // nogncheck
|
|
#include "modules/audio_device/include/audio_device.h" // nogncheck
|
|
#include "modules/audio_processing/include/audio_processing.h" // nogncheck
|
|
#endif
|
|
|
|
#include "Video/objcvideotracksource.h"
|
|
#include "api/videosourceproxy.h"
|
|
// Adding the nogncheck to disable the including header check.
|
|
// The no-media version PeerConnectionFactory doesn't depend on media related
|
|
// C++ target.
|
|
// TODO(zhihuang): Remove nogncheck once MediaEngineInterface is moved to C++
|
|
// API layer.
|
|
#include "media/engine/webrtcmediaengine.h" // nogncheck
|
|
#include "rtc_base/ptr_util.h"
|
|
|
|
@implementation RTCPeerConnectionFactory {
|
|
std::unique_ptr<rtc::Thread> _networkThread;
|
|
std::unique_ptr<rtc::Thread> _workerThread;
|
|
std::unique_ptr<rtc::Thread> _signalingThread;
|
|
BOOL _hasStartedAecDump;
|
|
}
|
|
|
|
@synthesize nativeFactory = _nativeFactory;
|
|
|
|
- (instancetype)init {
|
|
#ifdef HAVE_NO_MEDIA
|
|
return [self initWithNoMedia];
|
|
#elif !defined(USE_BUILTIN_SW_CODECS)
|
|
return [self initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
|
|
nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
|
|
nativeVideoEncoderFactory:std::unique_ptr<webrtc::VideoEncoderFactory>(
|
|
new webrtc::ObjCVideoEncoderFactory(
|
|
[[RTCVideoEncoderFactoryH264 alloc] init]))
|
|
nativeVideoDecoderFactory:std::unique_ptr<webrtc::VideoDecoderFactory>(
|
|
new webrtc::ObjCVideoDecoderFactory(
|
|
[[RTCVideoDecoderFactoryH264 alloc] init]))
|
|
audioDeviceModule:nullptr
|
|
audioProcessingModule:nullptr];
|
|
#else
|
|
return [self initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
|
|
nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
|
|
legacyNativeVideoEncoderFactory:new webrtc::ObjCVideoEncoderFactory(
|
|
[[RTCVideoEncoderFactoryH264 alloc] init])
|
|
legacyNativeVideoDecoderFactory:new webrtc::ObjCVideoDecoderFactory(
|
|
[[RTCVideoDecoderFactoryH264 alloc] init])
|
|
audioDeviceModule:nullptr];
|
|
|
|
#endif
|
|
}
|
|
|
|
- (instancetype)initWithEncoderFactory:(nullable id<RTCVideoEncoderFactory>)encoderFactory
|
|
decoderFactory:(nullable id<RTCVideoDecoderFactory>)decoderFactory {
|
|
#ifdef HAVE_NO_MEDIA
|
|
return [self initWithNoMedia];
|
|
#else
|
|
std::unique_ptr<webrtc::VideoEncoderFactory> native_encoder_factory;
|
|
std::unique_ptr<webrtc::VideoDecoderFactory> native_decoder_factory;
|
|
if (encoderFactory) {
|
|
native_encoder_factory.reset(new webrtc::ObjCVideoEncoderFactory(encoderFactory));
|
|
}
|
|
if (decoderFactory) {
|
|
native_decoder_factory.reset(new webrtc::ObjCVideoDecoderFactory(decoderFactory));
|
|
}
|
|
return [self initWithNativeAudioEncoderFactory:webrtc::CreateBuiltinAudioEncoderFactory()
|
|
nativeAudioDecoderFactory:webrtc::CreateBuiltinAudioDecoderFactory()
|
|
nativeVideoEncoderFactory:std::move(native_encoder_factory)
|
|
nativeVideoDecoderFactory:std::move(native_decoder_factory)
|
|
audioDeviceModule:nullptr
|
|
audioProcessingModule:nullptr];
|
|
#endif
|
|
}
|
|
|
|
- (instancetype)initNative {
|
|
if (self = [super init]) {
|
|
_networkThread = rtc::Thread::CreateWithSocketServer();
|
|
BOOL result = _networkThread->Start();
|
|
NSAssert(result, @"Failed to start network thread.");
|
|
|
|
_workerThread = rtc::Thread::Create();
|
|
result = _workerThread->Start();
|
|
NSAssert(result, @"Failed to start worker thread.");
|
|
|
|
_signalingThread = rtc::Thread::Create();
|
|
result = _signalingThread->Start();
|
|
NSAssert(result, @"Failed to start signaling thread.");
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (instancetype)initWithNoMedia {
|
|
if (self = [self initNative]) {
|
|
_nativeFactory = webrtc::CreateModularPeerConnectionFactory(
|
|
_networkThread.get(),
|
|
_workerThread.get(),
|
|
_signalingThread.get(),
|
|
std::unique_ptr<cricket::MediaEngineInterface>(),
|
|
std::unique_ptr<webrtc::CallFactoryInterface>(),
|
|
std::unique_ptr<webrtc::RtcEventLogFactoryInterface>());
|
|
NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (instancetype)initWithNativeAudioEncoderFactory:
|
|
(rtc::scoped_refptr<webrtc::AudioEncoderFactory>)audioEncoderFactory
|
|
nativeAudioDecoderFactory:
|
|
(rtc::scoped_refptr<webrtc::AudioDecoderFactory>)audioDecoderFactory
|
|
nativeVideoEncoderFactory:
|
|
(std::unique_ptr<webrtc::VideoEncoderFactory>)videoEncoderFactory
|
|
nativeVideoDecoderFactory:
|
|
(std::unique_ptr<webrtc::VideoDecoderFactory>)videoDecoderFactory
|
|
audioDeviceModule:
|
|
(nullable webrtc::AudioDeviceModule *)audioDeviceModule
|
|
audioProcessingModule:
|
|
(rtc::scoped_refptr<webrtc::AudioProcessing>)audioProcessingModule {
|
|
#ifdef HAVE_NO_MEDIA
|
|
return [self initWithNoMedia];
|
|
#else
|
|
if (self = [self initNative]) {
|
|
#if defined(USE_BUILTIN_SW_CODECS)
|
|
if (!videoEncoderFactory) {
|
|
auto legacy_video_encoder_factory = rtc::MakeUnique<webrtc::ObjCVideoEncoderFactory>(
|
|
[[RTCVideoEncoderFactoryH264 alloc] init]);
|
|
videoEncoderFactory = ConvertVideoEncoderFactory(std::move(legacy_video_encoder_factory));
|
|
}
|
|
if (!videoDecoderFactory) {
|
|
auto legacy_video_decoder_factory = rtc::MakeUnique<webrtc::ObjCVideoDecoderFactory>(
|
|
[[RTCVideoDecoderFactoryH264 alloc] init]);
|
|
videoDecoderFactory = ConvertVideoDecoderFactory(std::move(legacy_video_decoder_factory));
|
|
}
|
|
#endif
|
|
_nativeFactory = webrtc::CreatePeerConnectionFactory(_networkThread.get(),
|
|
_workerThread.get(),
|
|
_signalingThread.get(),
|
|
audioDeviceModule,
|
|
audioEncoderFactory,
|
|
audioDecoderFactory,
|
|
std::move(videoEncoderFactory),
|
|
std::move(videoDecoderFactory),
|
|
nullptr, // audio mixer
|
|
audioProcessingModule);
|
|
NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
|
|
}
|
|
return self;
|
|
#endif
|
|
}
|
|
|
|
#if defined(USE_BUILTIN_SW_CODECS)
|
|
- (instancetype)
|
|
initWithNativeAudioEncoderFactory:
|
|
(rtc::scoped_refptr<webrtc::AudioEncoderFactory>)audioEncoderFactory
|
|
nativeAudioDecoderFactory:
|
|
(rtc::scoped_refptr<webrtc::AudioDecoderFactory>)audioDecoderFactory
|
|
legacyNativeVideoEncoderFactory:(cricket::WebRtcVideoEncoderFactory *)videoEncoderFactory
|
|
legacyNativeVideoDecoderFactory:(cricket::WebRtcVideoDecoderFactory *)videoDecoderFactory
|
|
audioDeviceModule:(nullable webrtc::AudioDeviceModule *)audioDeviceModule {
|
|
#ifdef HAVE_NO_MEDIA
|
|
return [self initWithNoMedia];
|
|
#else
|
|
if (self = [self initNative]) {
|
|
_nativeFactory = webrtc::CreatePeerConnectionFactory(_networkThread.get(),
|
|
_workerThread.get(),
|
|
_signalingThread.get(),
|
|
audioDeviceModule,
|
|
audioEncoderFactory,
|
|
audioDecoderFactory,
|
|
videoEncoderFactory,
|
|
videoDecoderFactory);
|
|
NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
|
|
}
|
|
return self;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
- (RTCAudioSource *)audioSourceWithConstraints:(nullable RTCMediaConstraints *)constraints {
|
|
std::unique_ptr<webrtc::MediaConstraints> nativeConstraints;
|
|
if (constraints) {
|
|
nativeConstraints = constraints.nativeConstraints;
|
|
}
|
|
rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
|
|
_nativeFactory->CreateAudioSource(nativeConstraints.get());
|
|
return [[RTCAudioSource alloc] initWithNativeAudioSource:source];
|
|
}
|
|
|
|
- (RTCAudioTrack *)audioTrackWithTrackId:(NSString *)trackId {
|
|
RTCAudioSource *audioSource = [self audioSourceWithConstraints:nil];
|
|
return [self audioTrackWithSource:audioSource trackId:trackId];
|
|
}
|
|
|
|
- (RTCAudioTrack *)audioTrackWithSource:(RTCAudioSource *)source
|
|
trackId:(NSString *)trackId {
|
|
return [[RTCAudioTrack alloc] initWithFactory:self
|
|
source:source
|
|
trackId:trackId];
|
|
}
|
|
|
|
- (RTCAVFoundationVideoSource *)avFoundationVideoSourceWithConstraints:
|
|
(nullable RTCMediaConstraints *)constraints {
|
|
#ifdef HAVE_NO_MEDIA
|
|
return nil;
|
|
#else
|
|
return [[RTCAVFoundationVideoSource alloc] initWithFactory:self constraints:constraints];
|
|
#endif
|
|
}
|
|
|
|
- (RTCVideoSource *)videoSource {
|
|
rtc::scoped_refptr<webrtc::ObjcVideoTrackSource> objcVideoTrackSource(
|
|
new rtc::RefCountedObject<webrtc::ObjcVideoTrackSource>());
|
|
return [[RTCVideoSource alloc]
|
|
initWithNativeVideoSource:webrtc::VideoTrackSourceProxy::Create(_signalingThread.get(),
|
|
_workerThread.get(),
|
|
objcVideoTrackSource)];
|
|
}
|
|
|
|
- (RTCVideoTrack *)videoTrackWithSource:(RTCVideoSource *)source
|
|
trackId:(NSString *)trackId {
|
|
return [[RTCVideoTrack alloc] initWithFactory:self
|
|
source:source
|
|
trackId:trackId];
|
|
}
|
|
|
|
- (RTCMediaStream *)mediaStreamWithStreamId:(NSString *)streamId {
|
|
return [[RTCMediaStream alloc] initWithFactory:self
|
|
streamId:streamId];
|
|
}
|
|
|
|
- (RTCPeerConnection *)peerConnectionWithConfiguration:
|
|
(RTCConfiguration *)configuration
|
|
constraints:
|
|
(RTCMediaConstraints *)constraints
|
|
delegate:
|
|
(nullable id<RTCPeerConnectionDelegate>)delegate {
|
|
return [[RTCPeerConnection alloc] initWithFactory:self
|
|
configuration:configuration
|
|
constraints:constraints
|
|
delegate:delegate];
|
|
}
|
|
|
|
- (void)setOptions:(nonnull RTCPeerConnectionFactoryOptions *)options {
|
|
RTC_DCHECK(options != nil);
|
|
_nativeFactory->SetOptions(options.nativeOptions);
|
|
}
|
|
|
|
- (BOOL)startAecDumpWithFilePath:(NSString *)filePath
|
|
maxSizeInBytes:(int64_t)maxSizeInBytes {
|
|
RTC_DCHECK(filePath.length);
|
|
RTC_DCHECK_GT(maxSizeInBytes, 0);
|
|
|
|
if (_hasStartedAecDump) {
|
|
RTCLogError(@"Aec dump already started.");
|
|
return NO;
|
|
}
|
|
int fd = open(filePath.UTF8String, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
|
|
if (fd < 0) {
|
|
RTCLogError(@"Error opening file: %@. Error: %d", filePath, errno);
|
|
return NO;
|
|
}
|
|
_hasStartedAecDump = _nativeFactory->StartAecDump(fd, maxSizeInBytes);
|
|
return _hasStartedAecDump;
|
|
}
|
|
|
|
- (void)stopAecDump {
|
|
_nativeFactory->StopAecDump();
|
|
_hasStartedAecDump = NO;
|
|
}
|
|
|
|
@end
|