38ede13042
This CL makes the WebRTC more modular and allows the users to build WebRTC without audio and video(DataChannel only). The BUILD files in call/, logging/, media/ and pc/ are modified to support modular WebRTC. The dependencies on Call and RtcEventLog are removed from the PeerConnection. Instead of being created internally, they would be passed in by the PeerConnectionFactory. Add the CreateModularPeerConnectionFactory function which allow the users to create a PeerConnectionFactory with the modules they need. If the users want to build WebRTC without audio and video, they can pass in null pointers for modules they don't need. (MediaEngine, VideoEncoderFactory etc.) BUG=webrtc:7613 Review-Url: https://codereview.webrtc.org/2854123003 Cr-Commit-Position: refs/heads/master@{#18617}
460 lines
15 KiB
C++
460 lines
15 KiB
C++
/*
|
|
* Copyright 2004 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.
|
|
*/
|
|
|
|
#include "webrtc/pc/channelmanager.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include "webrtc/base/bind.h"
|
|
#include "webrtc/base/checks.h"
|
|
#include "webrtc/base/logging.h"
|
|
#include "webrtc/base/stringencode.h"
|
|
#include "webrtc/base/stringutils.h"
|
|
#include "webrtc/base/trace_event.h"
|
|
#include "webrtc/media/base/device.h"
|
|
#include "webrtc/media/base/rtpdataengine.h"
|
|
#include "webrtc/pc/srtpfilter.h"
|
|
|
|
namespace cricket {
|
|
|
|
|
|
using rtc::Bind;
|
|
|
|
ChannelManager::ChannelManager(std::unique_ptr<MediaEngineInterface> me,
|
|
std::unique_ptr<DataEngineInterface> dme,
|
|
rtc::Thread* thread) {
|
|
Construct(std::move(me), std::move(dme), thread, thread);
|
|
}
|
|
|
|
ChannelManager::ChannelManager(std::unique_ptr<MediaEngineInterface> me,
|
|
rtc::Thread* worker_thread,
|
|
rtc::Thread* network_thread) {
|
|
Construct(std::move(me),
|
|
std::unique_ptr<DataEngineInterface>(new RtpDataEngine()),
|
|
worker_thread, network_thread);
|
|
}
|
|
|
|
void ChannelManager::Construct(std::unique_ptr<MediaEngineInterface> me,
|
|
std::unique_ptr<DataEngineInterface> dme,
|
|
rtc::Thread* worker_thread,
|
|
rtc::Thread* network_thread) {
|
|
media_engine_ = std::move(me);
|
|
data_media_engine_ = std::move(dme);
|
|
initialized_ = false;
|
|
main_thread_ = rtc::Thread::Current();
|
|
worker_thread_ = worker_thread;
|
|
network_thread_ = network_thread;
|
|
capturing_ = false;
|
|
enable_rtx_ = false;
|
|
crypto_options_ = rtc::CryptoOptions::NoGcm();
|
|
}
|
|
|
|
ChannelManager::~ChannelManager() {
|
|
if (initialized_) {
|
|
Terminate();
|
|
// If srtp is initialized (done by the Channel) then we must call
|
|
// srtp_shutdown to free all crypto kernel lists. But we need to make sure
|
|
// shutdown always called at the end, after channels are destroyed.
|
|
// ChannelManager d'tor is always called last, it's safe place to call
|
|
// shutdown.
|
|
ShutdownSrtp();
|
|
}
|
|
// The media engine needs to be deleted on the worker thread for thread safe
|
|
// destruction,
|
|
worker_thread_->Invoke<void>(
|
|
RTC_FROM_HERE, Bind(&ChannelManager::DestructorDeletes_w, this));
|
|
}
|
|
|
|
bool ChannelManager::SetVideoRtxEnabled(bool enable) {
|
|
// To be safe, this call is only allowed before initialization. Apps like
|
|
// Flute only have a singleton ChannelManager and we don't want this flag to
|
|
// be toggled between calls or when there's concurrent calls. We expect apps
|
|
// to enable this at startup and retain that setting for the lifetime of the
|
|
// app.
|
|
if (!initialized_) {
|
|
enable_rtx_ = enable;
|
|
return true;
|
|
} else {
|
|
LOG(LS_WARNING) << "Cannot toggle rtx after initialization!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void ChannelManager::GetSupportedAudioSendCodecs(
|
|
std::vector<AudioCodec>* codecs) const {
|
|
if (!media_engine_) {
|
|
return;
|
|
}
|
|
*codecs = media_engine_->audio_send_codecs();
|
|
}
|
|
|
|
void ChannelManager::GetSupportedAudioReceiveCodecs(
|
|
std::vector<AudioCodec>* codecs) const {
|
|
if (!media_engine_) {
|
|
return;
|
|
}
|
|
*codecs = media_engine_->audio_recv_codecs();
|
|
}
|
|
|
|
void ChannelManager::GetSupportedAudioRtpHeaderExtensions(
|
|
RtpHeaderExtensions* ext) const {
|
|
if (!media_engine_) {
|
|
return;
|
|
}
|
|
*ext = media_engine_->GetAudioCapabilities().header_extensions;
|
|
}
|
|
|
|
void ChannelManager::GetSupportedVideoCodecs(
|
|
std::vector<VideoCodec>* codecs) const {
|
|
if (!media_engine_) {
|
|
return;
|
|
}
|
|
codecs->clear();
|
|
|
|
std::vector<VideoCodec> video_codecs = media_engine_->video_codecs();
|
|
for (const auto& video_codec : video_codecs) {
|
|
if (!enable_rtx_ &&
|
|
_stricmp(kRtxCodecName, video_codec.name.c_str()) == 0) {
|
|
continue;
|
|
}
|
|
codecs->push_back(video_codec);
|
|
}
|
|
}
|
|
|
|
void ChannelManager::GetSupportedVideoRtpHeaderExtensions(
|
|
RtpHeaderExtensions* ext) const {
|
|
if (!media_engine_) {
|
|
return;
|
|
}
|
|
*ext = media_engine_->GetVideoCapabilities().header_extensions;
|
|
}
|
|
|
|
void ChannelManager::GetSupportedDataCodecs(
|
|
std::vector<DataCodec>* codecs) const {
|
|
if (!data_media_engine_) {
|
|
return;
|
|
}
|
|
*codecs = data_media_engine_->data_codecs();
|
|
}
|
|
|
|
bool ChannelManager::Init() {
|
|
RTC_DCHECK(!initialized_);
|
|
if (initialized_) {
|
|
return false;
|
|
}
|
|
RTC_DCHECK(network_thread_);
|
|
RTC_DCHECK(worker_thread_);
|
|
if (!network_thread_->IsCurrent()) {
|
|
// Do not allow invoking calls to other threads on the network thread.
|
|
network_thread_->Invoke<bool>(
|
|
RTC_FROM_HERE,
|
|
rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
|
|
}
|
|
|
|
initialized_ = worker_thread_->Invoke<bool>(
|
|
RTC_FROM_HERE, Bind(&ChannelManager::InitMediaEngine_w, this));
|
|
RTC_DCHECK(initialized_);
|
|
return initialized_;
|
|
}
|
|
|
|
bool ChannelManager::InitMediaEngine_w() {
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
if (media_engine_) {
|
|
return media_engine_->Init();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void ChannelManager::Terminate() {
|
|
RTC_DCHECK(initialized_);
|
|
if (!initialized_) {
|
|
return;
|
|
}
|
|
worker_thread_->Invoke<void>(RTC_FROM_HERE,
|
|
Bind(&ChannelManager::Terminate_w, this));
|
|
initialized_ = false;
|
|
}
|
|
|
|
void ChannelManager::DestructorDeletes_w() {
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
media_engine_.reset(NULL);
|
|
}
|
|
|
|
void ChannelManager::Terminate_w() {
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
// Need to destroy the voice/video channels
|
|
while (!video_channels_.empty()) {
|
|
DestroyVideoChannel_w(video_channels_.back());
|
|
}
|
|
while (!voice_channels_.empty()) {
|
|
DestroyVoiceChannel_w(voice_channels_.back());
|
|
}
|
|
}
|
|
|
|
VoiceChannel* ChannelManager::CreateVoiceChannel(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_transport,
|
|
DtlsTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const AudioOptions& options) {
|
|
return worker_thread_->Invoke<VoiceChannel*>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
|
|
rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
|
|
signaling_thread, content_name, srtp_required, options));
|
|
}
|
|
|
|
VoiceChannel* ChannelManager::CreateVoiceChannel(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
rtc::PacketTransportInternal* rtp_transport,
|
|
rtc::PacketTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const AudioOptions& options) {
|
|
return worker_thread_->Invoke<VoiceChannel*>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::CreateVoiceChannel_w, this, call, media_config,
|
|
nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
|
|
content_name, srtp_required, options));
|
|
}
|
|
|
|
VoiceChannel* ChannelManager::CreateVoiceChannel_w(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_dtls_transport,
|
|
DtlsTransportInternal* rtcp_dtls_transport,
|
|
rtc::PacketTransportInternal* rtp_packet_transport,
|
|
rtc::PacketTransportInternal* rtcp_packet_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const AudioOptions& options) {
|
|
RTC_DCHECK(initialized_);
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
RTC_DCHECK(nullptr != call);
|
|
if (!media_engine_) {
|
|
return nullptr;
|
|
}
|
|
|
|
VoiceMediaChannel* media_channel = media_engine_->CreateChannel(
|
|
call, media_config, options);
|
|
if (!media_channel)
|
|
return nullptr;
|
|
|
|
VoiceChannel* voice_channel =
|
|
new VoiceChannel(worker_thread_, network_thread_, signaling_thread,
|
|
media_engine_.get(), media_channel, content_name,
|
|
rtcp_packet_transport == nullptr, srtp_required);
|
|
|
|
if (!voice_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
|
|
rtp_packet_transport, rtcp_packet_transport)) {
|
|
delete voice_channel;
|
|
return nullptr;
|
|
}
|
|
voice_channels_.push_back(voice_channel);
|
|
return voice_channel;
|
|
}
|
|
|
|
void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyVoiceChannel");
|
|
if (voice_channel) {
|
|
worker_thread_->Invoke<void>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::DestroyVoiceChannel_w, this, voice_channel));
|
|
}
|
|
}
|
|
|
|
void ChannelManager::DestroyVoiceChannel_w(VoiceChannel* voice_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyVoiceChannel_w");
|
|
// Destroy voice channel.
|
|
RTC_DCHECK(initialized_);
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
VoiceChannels::iterator it = std::find(voice_channels_.begin(),
|
|
voice_channels_.end(), voice_channel);
|
|
RTC_DCHECK(it != voice_channels_.end());
|
|
if (it == voice_channels_.end())
|
|
return;
|
|
voice_channels_.erase(it);
|
|
delete voice_channel;
|
|
}
|
|
|
|
VideoChannel* ChannelManager::CreateVideoChannel(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_transport,
|
|
DtlsTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const VideoOptions& options) {
|
|
return worker_thread_->Invoke<VideoChannel*>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
|
|
rtp_transport, rtcp_transport, rtp_transport, rtcp_transport,
|
|
signaling_thread, content_name, srtp_required, options));
|
|
}
|
|
|
|
VideoChannel* ChannelManager::CreateVideoChannel(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
rtc::PacketTransportInternal* rtp_transport,
|
|
rtc::PacketTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const VideoOptions& options) {
|
|
return worker_thread_->Invoke<VideoChannel*>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::CreateVideoChannel_w, this, call, media_config,
|
|
nullptr, nullptr, rtp_transport, rtcp_transport, signaling_thread,
|
|
content_name, srtp_required, options));
|
|
}
|
|
|
|
VideoChannel* ChannelManager::CreateVideoChannel_w(
|
|
webrtc::Call* call,
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_dtls_transport,
|
|
DtlsTransportInternal* rtcp_dtls_transport,
|
|
rtc::PacketTransportInternal* rtp_packet_transport,
|
|
rtc::PacketTransportInternal* rtcp_packet_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required,
|
|
const VideoOptions& options) {
|
|
RTC_DCHECK(initialized_);
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
RTC_DCHECK(nullptr != call);
|
|
VideoMediaChannel* media_channel = media_engine_->CreateVideoChannel(
|
|
call, media_config, options);
|
|
if (media_channel == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
VideoChannel* video_channel = new VideoChannel(
|
|
worker_thread_, network_thread_, signaling_thread, media_channel,
|
|
content_name, rtcp_packet_transport == nullptr, srtp_required);
|
|
if (!video_channel->Init_w(rtp_dtls_transport, rtcp_dtls_transport,
|
|
rtp_packet_transport, rtcp_packet_transport)) {
|
|
delete video_channel;
|
|
return NULL;
|
|
}
|
|
video_channels_.push_back(video_channel);
|
|
return video_channel;
|
|
}
|
|
|
|
void ChannelManager::DestroyVideoChannel(VideoChannel* video_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyVideoChannel");
|
|
if (video_channel) {
|
|
worker_thread_->Invoke<void>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::DestroyVideoChannel_w, this, video_channel));
|
|
}
|
|
}
|
|
|
|
void ChannelManager::DestroyVideoChannel_w(VideoChannel* video_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyVideoChannel_w");
|
|
// Destroy video channel.
|
|
RTC_DCHECK(initialized_);
|
|
RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
|
|
VideoChannels::iterator it = std::find(video_channels_.begin(),
|
|
video_channels_.end(), video_channel);
|
|
RTC_DCHECK(it != video_channels_.end());
|
|
if (it == video_channels_.end())
|
|
return;
|
|
|
|
video_channels_.erase(it);
|
|
delete video_channel;
|
|
}
|
|
|
|
RtpDataChannel* ChannelManager::CreateRtpDataChannel(
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_transport,
|
|
DtlsTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required) {
|
|
return worker_thread_->Invoke<RtpDataChannel*>(
|
|
RTC_FROM_HERE, Bind(&ChannelManager::CreateRtpDataChannel_w, this,
|
|
media_config, rtp_transport, rtcp_transport,
|
|
signaling_thread, content_name, srtp_required));
|
|
}
|
|
|
|
RtpDataChannel* ChannelManager::CreateRtpDataChannel_w(
|
|
const cricket::MediaConfig& media_config,
|
|
DtlsTransportInternal* rtp_transport,
|
|
DtlsTransportInternal* rtcp_transport,
|
|
rtc::Thread* signaling_thread,
|
|
const std::string& content_name,
|
|
bool srtp_required) {
|
|
// This is ok to alloc from a thread other than the worker thread.
|
|
RTC_DCHECK(initialized_);
|
|
DataMediaChannel* media_channel
|
|
= data_media_engine_->CreateChannel(media_config);
|
|
if (!media_channel) {
|
|
LOG(LS_WARNING) << "Failed to create RTP data channel.";
|
|
return nullptr;
|
|
}
|
|
|
|
RtpDataChannel* data_channel = new RtpDataChannel(
|
|
worker_thread_, network_thread_, signaling_thread, media_channel,
|
|
content_name, rtcp_transport == nullptr, srtp_required);
|
|
if (!data_channel->Init_w(rtp_transport, rtcp_transport, rtp_transport,
|
|
rtcp_transport)) {
|
|
LOG(LS_WARNING) << "Failed to init data channel.";
|
|
delete data_channel;
|
|
return nullptr;
|
|
}
|
|
data_channels_.push_back(data_channel);
|
|
return data_channel;
|
|
}
|
|
|
|
void ChannelManager::DestroyRtpDataChannel(RtpDataChannel* data_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyRtpDataChannel");
|
|
if (data_channel) {
|
|
worker_thread_->Invoke<void>(
|
|
RTC_FROM_HERE,
|
|
Bind(&ChannelManager::DestroyRtpDataChannel_w, this, data_channel));
|
|
}
|
|
}
|
|
|
|
void ChannelManager::DestroyRtpDataChannel_w(RtpDataChannel* data_channel) {
|
|
TRACE_EVENT0("webrtc", "ChannelManager::DestroyRtpDataChannel_w");
|
|
// Destroy data channel.
|
|
RTC_DCHECK(initialized_);
|
|
RtpDataChannels::iterator it =
|
|
std::find(data_channels_.begin(), data_channels_.end(), data_channel);
|
|
RTC_DCHECK(it != data_channels_.end());
|
|
if (it == data_channels_.end())
|
|
return;
|
|
|
|
data_channels_.erase(it);
|
|
delete data_channel;
|
|
}
|
|
|
|
bool ChannelManager::StartAecDump(rtc::PlatformFile file,
|
|
int64_t max_size_bytes) {
|
|
return worker_thread_->Invoke<bool>(
|
|
RTC_FROM_HERE, Bind(&MediaEngineInterface::StartAecDump,
|
|
media_engine_.get(), file, max_size_bytes));
|
|
}
|
|
|
|
void ChannelManager::StopAecDump() {
|
|
worker_thread_->Invoke<void>(
|
|
RTC_FROM_HERE,
|
|
Bind(&MediaEngineInterface::StopAecDump, media_engine_.get()));
|
|
}
|
|
|
|
} // namespace cricket
|