From cb06cac5b4032ec7d98a4f0454ffd8734a0d91ff Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Thu, 18 Oct 2018 17:03:30 +0200 Subject: [PATCH] Moves fake media engine implementation to cc file. This CL moves the implementations of the fake media engine from fakemediaengine.h to fakemediaengine.cc. Bug: webrtc:9883 Change-Id: I0f91ef63a366abe9638fc885bc14aba7dd5436aa Reviewed-on: https://webrtc-review.googlesource.com/c/106923 Reviewed-by: Niels Moller Commit-Queue: Sebastian Jansson Cr-Commit-Position: refs/heads/master@{#25260} --- media/BUILD.gn | 1 + media/base/fakemediaengine.cc | 637 +++++++++++++++++++++++++++++++++ media/base/fakemediaengine.h | 644 ++++++++-------------------------- 3 files changed, 782 insertions(+), 500 deletions(-) create mode 100644 media/base/fakemediaengine.cc diff --git a/media/BUILD.gn b/media/BUILD.gn index be3fd3756d..3bac86b9c2 100644 --- a/media/BUILD.gn +++ b/media/BUILD.gn @@ -414,6 +414,7 @@ if (rtc_include_tests) { sources = [ "base/fakeframesource.cc", "base/fakeframesource.h", + "base/fakemediaengine.cc", "base/fakemediaengine.h", "base/fakenetworkinterface.h", "base/fakertp.cc", diff --git a/media/base/fakemediaengine.cc b/media/base/fakemediaengine.cc new file mode 100644 index 0000000000..ca58612755 --- /dev/null +++ b/media/base/fakemediaengine.cc @@ -0,0 +1,637 @@ +/* + * Copyright 2018 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 "media/base/fakemediaengine.h" + +#include + +#include "rtc_base/checks.h" + +namespace cricket { + +FakeVoiceMediaChannel::DtmfInfo::DtmfInfo(uint32_t ssrc, + int event_code, + int duration) + : ssrc(ssrc), event_code(event_code), duration(duration) {} + +FakeVoiceMediaChannel::VoiceChannelAudioSink::VoiceChannelAudioSink( + AudioSource* source) + : source_(source) { + source_->SetSink(this); +} +FakeVoiceMediaChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() { + if (source_) { + source_->SetSink(nullptr); + } +} +void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnData( + const void* audio_data, + int bits_per_sample, + int sample_rate, + size_t number_of_channels, + size_t number_of_frames) {} +void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnClose() { + source_ = nullptr; +} +AudioSource* FakeVoiceMediaChannel::VoiceChannelAudioSink::source() const { + return source_; +} + +FakeVoiceMediaChannel::FakeVoiceMediaChannel(FakeVoiceEngine* engine, + const AudioOptions& options) + : engine_(engine), max_bps_(-1) { + output_scalings_[0] = 1.0; // For default channel. + SetOptions(options); +} +FakeVoiceMediaChannel::~FakeVoiceMediaChannel() { + if (engine_) { + engine_->UnregisterChannel(this); + } +} +const std::vector& FakeVoiceMediaChannel::recv_codecs() const { + return recv_codecs_; +} +const std::vector& FakeVoiceMediaChannel::send_codecs() const { + return send_codecs_; +} +const std::vector& FakeVoiceMediaChannel::codecs() const { + return send_codecs(); +} +const std::vector& +FakeVoiceMediaChannel::dtmf_info_queue() const { + return dtmf_info_queue_; +} +const AudioOptions& FakeVoiceMediaChannel::options() const { + return options_; +} +int FakeVoiceMediaChannel::max_bps() const { + return max_bps_; +} +bool FakeVoiceMediaChannel::SetSendParameters( + const AudioSendParameters& params) { + set_send_rtcp_parameters(params.rtcp); + return (SetSendCodecs(params.codecs) && + SetSendRtpHeaderExtensions(params.extensions) && + SetMaxSendBandwidth(params.max_bandwidth_bps) && + SetOptions(params.options)); +} +bool FakeVoiceMediaChannel::SetRecvParameters( + const AudioRecvParameters& params) { + set_recv_rtcp_parameters(params.rtcp); + return (SetRecvCodecs(params.codecs) && + SetRecvRtpHeaderExtensions(params.extensions)); +} +void FakeVoiceMediaChannel::SetPlayout(bool playout) { + set_playout(playout); +} +void FakeVoiceMediaChannel::SetSend(bool send) { + set_sending(send); +} +bool FakeVoiceMediaChannel::SetAudioSend(uint32_t ssrc, + bool enable, + const AudioOptions* options, + AudioSource* source) { + if (!SetLocalSource(ssrc, source)) { + return false; + } + if (!RtpHelper::MuteStream(ssrc, !enable)) { + return false; + } + if (enable && options) { + return SetOptions(*options); + } + return true; +} +bool FakeVoiceMediaChannel::HasSource(uint32_t ssrc) const { + return local_sinks_.find(ssrc) != local_sinks_.end(); +} +bool FakeVoiceMediaChannel::AddRecvStream(const StreamParams& sp) { + if (!RtpHelper::AddRecvStream(sp)) + return false; + output_scalings_[sp.first_ssrc()] = 1.0; + return true; +} +bool FakeVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) { + if (!RtpHelper::RemoveRecvStream(ssrc)) + return false; + output_scalings_.erase(ssrc); + return true; +} +bool FakeVoiceMediaChannel::CanInsertDtmf() { + for (std::vector::const_iterator it = send_codecs_.begin(); + it != send_codecs_.end(); ++it) { + // Find the DTMF telephone event "codec". + if (_stricmp(it->name.c_str(), "telephone-event") == 0) { + return true; + } + } + return false; +} +bool FakeVoiceMediaChannel::InsertDtmf(uint32_t ssrc, + int event_code, + int duration) { + dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration)); + return true; +} +bool FakeVoiceMediaChannel::SetOutputVolume(uint32_t ssrc, double volume) { + if (0 == ssrc) { + std::map::iterator it; + for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) { + it->second = volume; + } + return true; + } else if (output_scalings_.find(ssrc) != output_scalings_.end()) { + output_scalings_[ssrc] = volume; + return true; + } + return false; +} +bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) { + if (output_scalings_.find(ssrc) == output_scalings_.end()) + return false; + *volume = output_scalings_[ssrc]; + return true; +} +bool FakeVoiceMediaChannel::GetStats(VoiceMediaInfo* info) { + return false; +} +void FakeVoiceMediaChannel::SetRawAudioSink( + uint32_t ssrc, + std::unique_ptr sink) { + sink_ = std::move(sink); +} +std::vector FakeVoiceMediaChannel::GetSources( + uint32_t ssrc) const { + return std::vector(); +} +bool FakeVoiceMediaChannel::SetRecvCodecs( + const std::vector& codecs) { + if (fail_set_recv_codecs()) { + // Fake the failure in SetRecvCodecs. + return false; + } + recv_codecs_ = codecs; + return true; +} +bool FakeVoiceMediaChannel::SetSendCodecs( + const std::vector& codecs) { + if (fail_set_send_codecs()) { + // Fake the failure in SetSendCodecs. + return false; + } + send_codecs_ = codecs; + return true; +} +bool FakeVoiceMediaChannel::SetMaxSendBandwidth(int bps) { + max_bps_ = bps; + return true; +} +bool FakeVoiceMediaChannel::SetOptions(const AudioOptions& options) { + // Does a "merge" of current options and set options. + options_.SetAll(options); + return true; +} +bool FakeVoiceMediaChannel::SetLocalSource(uint32_t ssrc, AudioSource* source) { + auto it = local_sinks_.find(ssrc); + if (source) { + if (it != local_sinks_.end()) { + RTC_CHECK(it->second->source() == source); + } else { + local_sinks_.insert(std::make_pair( + ssrc, absl::make_unique(source))); + } + } else { + if (it != local_sinks_.end()) { + local_sinks_.erase(it); + } + } + return true; +} + +bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info, + uint32_t ssrc, + int event_code, + int duration) { + return (info.duration == duration && info.event_code == event_code && + info.ssrc == ssrc); +} + +FakeVideoMediaChannel::FakeVideoMediaChannel(FakeVideoEngine* engine, + const VideoOptions& options) + : engine_(engine), max_bps_(-1) { + SetOptions(options); +} +FakeVideoMediaChannel::~FakeVideoMediaChannel() { + if (engine_) { + engine_->UnregisterChannel(this); + } +} +const std::vector& FakeVideoMediaChannel::recv_codecs() const { + return recv_codecs_; +} +const std::vector& FakeVideoMediaChannel::send_codecs() const { + return send_codecs_; +} +const std::vector& FakeVideoMediaChannel::codecs() const { + return send_codecs(); +} +bool FakeVideoMediaChannel::rendering() const { + return playout(); +} +const VideoOptions& FakeVideoMediaChannel::options() const { + return options_; +} +const std::map*>& +FakeVideoMediaChannel::sinks() const { + return sinks_; +} +int FakeVideoMediaChannel::max_bps() const { + return max_bps_; +} +bool FakeVideoMediaChannel::SetSendParameters( + const VideoSendParameters& params) { + set_send_rtcp_parameters(params.rtcp); + return (SetSendCodecs(params.codecs) && + SetSendRtpHeaderExtensions(params.extensions) && + SetMaxSendBandwidth(params.max_bandwidth_bps)); +} +bool FakeVideoMediaChannel::SetRecvParameters( + const VideoRecvParameters& params) { + set_recv_rtcp_parameters(params.rtcp); + return (SetRecvCodecs(params.codecs) && + SetRecvRtpHeaderExtensions(params.extensions)); +} +bool FakeVideoMediaChannel::AddSendStream(const StreamParams& sp) { + return RtpHelper::AddSendStream(sp); +} +bool FakeVideoMediaChannel::RemoveSendStream(uint32_t ssrc) { + return RtpHelper::RemoveSendStream(ssrc); +} +bool FakeVideoMediaChannel::GetSendCodec(VideoCodec* send_codec) { + if (send_codecs_.empty()) { + return false; + } + *send_codec = send_codecs_[0]; + return true; +} +bool FakeVideoMediaChannel::SetSink( + uint32_t ssrc, + rtc::VideoSinkInterface* sink) { + if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) { + return false; + } + if (ssrc != 0) { + sinks_[ssrc] = sink; + } + return true; +} +bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const { + return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr; +} +bool FakeVideoMediaChannel::SetSend(bool send) { + return set_sending(send); +} +bool FakeVideoMediaChannel::SetVideoSend( + uint32_t ssrc, + const VideoOptions* options, + rtc::VideoSourceInterface* source) { + if (options) { + if (!SetOptions(*options)) { + return false; + } + } + sources_[ssrc] = source; + return true; +} +bool FakeVideoMediaChannel::HasSource(uint32_t ssrc) const { + return sources_.find(ssrc) != sources_.end() && sources_.at(ssrc) != nullptr; +} +bool FakeVideoMediaChannel::AddRecvStream(const StreamParams& sp) { + if (!RtpHelper::AddRecvStream(sp)) + return false; + sinks_[sp.first_ssrc()] = NULL; + return true; +} +bool FakeVideoMediaChannel::RemoveRecvStream(uint32_t ssrc) { + if (!RtpHelper::RemoveRecvStream(ssrc)) + return false; + sinks_.erase(ssrc); + return true; +} +void FakeVideoMediaChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) { +} +bool FakeVideoMediaChannel::GetStats(VideoMediaInfo* info) { + return false; +} +std::vector FakeVideoMediaChannel::GetSources( + uint32_t ssrc) const { + return {}; +} +bool FakeVideoMediaChannel::SetRecvCodecs( + const std::vector& codecs) { + if (fail_set_recv_codecs()) { + // Fake the failure in SetRecvCodecs. + return false; + } + recv_codecs_ = codecs; + return true; +} +bool FakeVideoMediaChannel::SetSendCodecs( + const std::vector& codecs) { + if (fail_set_send_codecs()) { + // Fake the failure in SetSendCodecs. + return false; + } + send_codecs_ = codecs; + + return true; +} +bool FakeVideoMediaChannel::SetOptions(const VideoOptions& options) { + options_ = options; + return true; +} +bool FakeVideoMediaChannel::SetMaxSendBandwidth(int bps) { + max_bps_ = bps; + return true; +} + +FakeDataMediaChannel::FakeDataMediaChannel(void* unused, + const DataOptions& options) + : send_blocked_(false), max_bps_(-1) {} +FakeDataMediaChannel::~FakeDataMediaChannel() {} +const std::vector& FakeDataMediaChannel::recv_codecs() const { + return recv_codecs_; +} +const std::vector& FakeDataMediaChannel::send_codecs() const { + return send_codecs_; +} +const std::vector& FakeDataMediaChannel::codecs() const { + return send_codecs(); +} +int FakeDataMediaChannel::max_bps() const { + return max_bps_; +} +bool FakeDataMediaChannel::SetSendParameters(const DataSendParameters& params) { + set_send_rtcp_parameters(params.rtcp); + return (SetSendCodecs(params.codecs) && + SetMaxSendBandwidth(params.max_bandwidth_bps)); +} +bool FakeDataMediaChannel::SetRecvParameters(const DataRecvParameters& params) { + set_recv_rtcp_parameters(params.rtcp); + return SetRecvCodecs(params.codecs); +} +bool FakeDataMediaChannel::SetSend(bool send) { + return set_sending(send); +} +bool FakeDataMediaChannel::SetReceive(bool receive) { + set_playout(receive); + return true; +} +bool FakeDataMediaChannel::AddRecvStream(const StreamParams& sp) { + if (!RtpHelper::AddRecvStream(sp)) + return false; + return true; +} +bool FakeDataMediaChannel::RemoveRecvStream(uint32_t ssrc) { + if (!RtpHelper::RemoveRecvStream(ssrc)) + return false; + return true; +} +bool FakeDataMediaChannel::SendData(const SendDataParams& params, + const rtc::CopyOnWriteBuffer& payload, + SendDataResult* result) { + if (send_blocked_) { + *result = SDR_BLOCK; + return false; + } else { + last_sent_data_params_ = params; + last_sent_data_ = std::string(payload.data(), payload.size()); + return true; + } +} +SendDataParams FakeDataMediaChannel::last_sent_data_params() { + return last_sent_data_params_; +} +std::string FakeDataMediaChannel::last_sent_data() { + return last_sent_data_; +} +bool FakeDataMediaChannel::is_send_blocked() { + return send_blocked_; +} +void FakeDataMediaChannel::set_send_blocked(bool blocked) { + send_blocked_ = blocked; +} +bool FakeDataMediaChannel::SetRecvCodecs(const std::vector& codecs) { + if (fail_set_recv_codecs()) { + // Fake the failure in SetRecvCodecs. + return false; + } + recv_codecs_ = codecs; + return true; +} +bool FakeDataMediaChannel::SetSendCodecs(const std::vector& codecs) { + if (fail_set_send_codecs()) { + // Fake the failure in SetSendCodecs. + return false; + } + send_codecs_ = codecs; + return true; +} +bool FakeDataMediaChannel::SetMaxSendBandwidth(int bps) { + max_bps_ = bps; + return true; +} + +FakeBaseEngine::FakeBaseEngine() + : options_changed_(false), fail_create_channel_(false) {} +void FakeBaseEngine::set_fail_create_channel(bool fail) { + fail_create_channel_ = fail; +} +void FakeBaseEngine::set_rtp_header_extensions( + const std::vector& extensions) { + capabilities_.header_extensions = extensions; +} +void FakeBaseEngine::set_rtp_header_extensions( + const std::vector& extensions) { + for (const cricket::RtpHeaderExtension& ext : extensions) { + RtpExtension webrtc_ext; + webrtc_ext.uri = ext.uri; + webrtc_ext.id = ext.id; + capabilities_.header_extensions.push_back(webrtc_ext); + } +} + +FakeVoiceEngine::FakeVoiceEngine() { + // Add a fake audio codec. Note that the name must not be "" as there are + // sanity checks against that. + codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1)); +} +RtpCapabilities FakeVoiceEngine::GetCapabilities() const { + return capabilities_; +} +void FakeVoiceEngine::Init() {} +rtc::scoped_refptr FakeVoiceEngine::GetAudioState() const { + return rtc::scoped_refptr(); +} +VoiceMediaChannel* FakeVoiceEngine::CreateChannel( + webrtc::Call* call, + const MediaConfig& config, + const AudioOptions& options, + const webrtc::CryptoOptions& crypto_options) { + if (fail_create_channel_) { + return nullptr; + } + + FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this, options); + channels_.push_back(ch); + return ch; +} +FakeVoiceMediaChannel* FakeVoiceEngine::GetChannel(size_t index) { + return (channels_.size() > index) ? channels_[index] : NULL; +} +void FakeVoiceEngine::UnregisterChannel(VoiceMediaChannel* channel) { + channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); +} +const std::vector& FakeVoiceEngine::send_codecs() const { + return codecs_; +} +const std::vector& FakeVoiceEngine::recv_codecs() const { + return codecs_; +} +void FakeVoiceEngine::SetCodecs(const std::vector& codecs) { + codecs_ = codecs; +} +int FakeVoiceEngine::GetInputLevel() { + return 0; +} +bool FakeVoiceEngine::StartAecDump(rtc::PlatformFile file, + int64_t max_size_bytes) { + return false; +} +void FakeVoiceEngine::StopAecDump() {} +bool FakeVoiceEngine::StartRtcEventLog(rtc::PlatformFile file, + int64_t max_size_bytes) { + return false; +} +void FakeVoiceEngine::StopRtcEventLog() {} + +FakeVideoEngine::FakeVideoEngine() : capture_(false) { + // Add a fake video codec. Note that the name must not be "" as there are + // sanity checks against that. + codecs_.push_back(VideoCodec(0, "fake_video_codec")); +} +RtpCapabilities FakeVideoEngine::GetCapabilities() const { + return capabilities_; +} +bool FakeVideoEngine::SetOptions(const VideoOptions& options) { + options_ = options; + options_changed_ = true; + return true; +} +VideoMediaChannel* FakeVideoEngine::CreateChannel( + webrtc::Call* call, + const MediaConfig& config, + const VideoOptions& options, + const webrtc::CryptoOptions& crypto_options) { + if (fail_create_channel_) { + return nullptr; + } + + FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options); + channels_.emplace_back(ch); + return ch; +} +FakeVideoMediaChannel* FakeVideoEngine::GetChannel(size_t index) { + return (channels_.size() > index) ? channels_[index] : nullptr; +} +void FakeVideoEngine::UnregisterChannel(VideoMediaChannel* channel) { + auto it = std::find(channels_.begin(), channels_.end(), channel); + RTC_DCHECK(it != channels_.end()); + channels_.erase(it); +} +std::vector FakeVideoEngine::codecs() const { + return codecs_; +} +void FakeVideoEngine::SetCodecs(const std::vector codecs) { + codecs_ = codecs; +} +bool FakeVideoEngine::SetCapture(bool capture) { + capture_ = capture; + return true; +} + +FakeMediaEngine::FakeMediaEngine() + : CompositeMediaEngine(std::tuple<>(), + std::tuple<>()), + voice_(&voice()), + video_(&video()) {} +FakeMediaEngine::~FakeMediaEngine() {} +void FakeMediaEngine::SetAudioCodecs(const std::vector& codecs) { + voice_->SetCodecs(codecs); +} +void FakeMediaEngine::SetVideoCodecs(const std::vector& codecs) { + video_->SetCodecs(codecs); +} +void FakeMediaEngine::SetAudioRtpHeaderExtensions( + const std::vector& extensions) { + voice_->set_rtp_header_extensions(extensions); +} +void FakeMediaEngine::SetVideoRtpHeaderExtensions( + const std::vector& extensions) { + video_->set_rtp_header_extensions(extensions); +} +void FakeMediaEngine::SetAudioRtpHeaderExtensions( + const std::vector& extensions) { + voice_->set_rtp_header_extensions(extensions); +} +void FakeMediaEngine::SetVideoRtpHeaderExtensions( + const std::vector& extensions) { + video_->set_rtp_header_extensions(extensions); +} +FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) { + return voice_->GetChannel(index); +} +FakeVideoMediaChannel* FakeMediaEngine::GetVideoChannel(size_t index) { + return video_->GetChannel(index); +} + +bool FakeMediaEngine::capture() const { + return video_->capture_; +} +bool FakeMediaEngine::options_changed() const { + return video_->options_changed_; +} +void FakeMediaEngine::clear_options_changed() { + video_->options_changed_ = false; +} +void FakeMediaEngine::set_fail_create_channel(bool fail) { + voice_->set_fail_create_channel(fail); + video_->set_fail_create_channel(fail); +} + +DataMediaChannel* FakeDataEngine::CreateChannel(const MediaConfig& config) { + FakeDataMediaChannel* ch = new FakeDataMediaChannel(this, DataOptions()); + channels_.push_back(ch); + return ch; +} +FakeDataMediaChannel* FakeDataEngine::GetChannel(size_t index) { + return (channels_.size() > index) ? channels_[index] : NULL; +} +void FakeDataEngine::UnregisterChannel(DataMediaChannel* channel) { + channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); +} +void FakeDataEngine::SetDataCodecs(const std::vector& data_codecs) { + data_codecs_ = data_codecs; +} +const std::vector& FakeDataEngine::data_codecs() { + return data_codecs_; +} + +} // namespace cricket diff --git a/media/base/fakemediaengine.h b/media/base/fakemediaengine.h index a20beb0f28..e6344e646f 100644 --- a/media/base/fakemediaengine.h +++ b/media/base/fakemediaengine.h @@ -17,10 +17,8 @@ #include #include #include -#include #include -#include "absl/memory/memory.h" #include "api/call/audio_sink.h" #include "media/base/audiosource.h" #include "media/base/mediaengine.h" @@ -28,10 +26,8 @@ #include "media/base/streamparams.h" #include "media/engine/webrtcvideoengine.h" #include "modules/audio_processing/include/audio_processing.h" -#include "rtc_base/checks.h" #include "rtc_base/copyonwritebuffer.h" #include "rtc_base/networkroute.h" -#include "rtc_base/stringutils.h" using webrtc::RtpExtension; @@ -312,187 +308,72 @@ class RtpHelper : public Base { class FakeVoiceMediaChannel : public RtpHelper { public: struct DtmfInfo { - DtmfInfo(uint32_t ssrc, int event_code, int duration) - : ssrc(ssrc), event_code(event_code), duration(duration) {} + DtmfInfo(uint32_t ssrc, int event_code, int duration); uint32_t ssrc; int event_code; int duration; }; explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine, - const AudioOptions& options) - : engine_(engine), max_bps_(-1) { - output_scalings_[0] = 1.0; // For default channel. - SetOptions(options); - } + const AudioOptions& options); ~FakeVoiceMediaChannel(); - const std::vector& recv_codecs() const { return recv_codecs_; } - const std::vector& send_codecs() const { return send_codecs_; } - const std::vector& codecs() const { return send_codecs(); } - const std::vector& dtmf_info_queue() const { - return dtmf_info_queue_; - } - const AudioOptions& options() const { return options_; } - int max_bps() const { return max_bps_; } - virtual bool SetSendParameters(const AudioSendParameters& params) { - set_send_rtcp_parameters(params.rtcp); - return (SetSendCodecs(params.codecs) && - SetSendRtpHeaderExtensions(params.extensions) && - SetMaxSendBandwidth(params.max_bandwidth_bps) && - SetOptions(params.options)); - } + const std::vector& recv_codecs() const; + const std::vector& send_codecs() const; + const std::vector& codecs() const; + const std::vector& dtmf_info_queue() const; + const AudioOptions& options() const; + int max_bps() const; + bool SetSendParameters(const AudioSendParameters& params) override; - virtual bool SetRecvParameters(const AudioRecvParameters& params) { - set_recv_rtcp_parameters(params.rtcp); - return (SetRecvCodecs(params.codecs) && - SetRecvRtpHeaderExtensions(params.extensions)); - } + bool SetRecvParameters(const AudioRecvParameters& params) override; - virtual void SetPlayout(bool playout) { set_playout(playout); } - virtual void SetSend(bool send) { set_sending(send); } - virtual bool SetAudioSend(uint32_t ssrc, - bool enable, - const AudioOptions* options, - AudioSource* source) { - if (!SetLocalSource(ssrc, source)) { - return false; - } - if (!RtpHelper::MuteStream(ssrc, !enable)) { - return false; - } - if (enable && options) { - return SetOptions(*options); - } - return true; - } + void SetPlayout(bool playout) override; + void SetSend(bool send) override; + bool SetAudioSend(uint32_t ssrc, + bool enable, + const AudioOptions* options, + AudioSource* source) override; - bool HasSource(uint32_t ssrc) const { - return local_sinks_.find(ssrc) != local_sinks_.end(); - } + bool HasSource(uint32_t ssrc) const; - virtual bool AddRecvStream(const StreamParams& sp) { - if (!RtpHelper::AddRecvStream(sp)) - return false; - output_scalings_[sp.first_ssrc()] = 1.0; - return true; - } - virtual bool RemoveRecvStream(uint32_t ssrc) { - if (!RtpHelper::RemoveRecvStream(ssrc)) - return false; - output_scalings_.erase(ssrc); - return true; - } + bool AddRecvStream(const StreamParams& sp) override; + bool RemoveRecvStream(uint32_t ssrc) override; - virtual bool CanInsertDtmf() { - for (std::vector::const_iterator it = send_codecs_.begin(); - it != send_codecs_.end(); ++it) { - // Find the DTMF telephone event "codec". - if (_stricmp(it->name.c_str(), "telephone-event") == 0) { - return true; - } - } - return false; - } - virtual bool InsertDtmf(uint32_t ssrc, int event_code, int duration) { - dtmf_info_queue_.push_back(DtmfInfo(ssrc, event_code, duration)); - return true; - } + bool CanInsertDtmf() override; + bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override; - virtual bool SetOutputVolume(uint32_t ssrc, double volume) { - if (0 == ssrc) { - std::map::iterator it; - for (it = output_scalings_.begin(); it != output_scalings_.end(); ++it) { - it->second = volume; - } - return true; - } else if (output_scalings_.find(ssrc) != output_scalings_.end()) { - output_scalings_[ssrc] = volume; - return true; - } - return false; - } - bool GetOutputVolume(uint32_t ssrc, double* volume) { - if (output_scalings_.find(ssrc) == output_scalings_.end()) - return false; - *volume = output_scalings_[ssrc]; - return true; - } + bool SetOutputVolume(uint32_t ssrc, double volume) override; + bool GetOutputVolume(uint32_t ssrc, double* volume); - virtual bool GetStats(VoiceMediaInfo* info) { return false; } + bool GetStats(VoiceMediaInfo* info) override; - virtual void SetRawAudioSink( + void SetRawAudioSink( uint32_t ssrc, - std::unique_ptr sink) { - sink_ = std::move(sink); - } + std::unique_ptr sink) override; - virtual std::vector GetSources(uint32_t ssrc) const { - return std::vector(); - } + std::vector GetSources(uint32_t ssrc) const override; private: class VoiceChannelAudioSink : public AudioSource::Sink { public: - explicit VoiceChannelAudioSink(AudioSource* source) : source_(source) { - source_->SetSink(this); - } - virtual ~VoiceChannelAudioSink() { - if (source_) { - source_->SetSink(nullptr); - } - } + explicit VoiceChannelAudioSink(AudioSource* source); + ~VoiceChannelAudioSink() override; void OnData(const void* audio_data, int bits_per_sample, int sample_rate, size_t number_of_channels, - size_t number_of_frames) override {} - void OnClose() override { source_ = nullptr; } - AudioSource* source() const { return source_; } + size_t number_of_frames) override; + void OnClose() override; + AudioSource* source() const; private: AudioSource* source_; }; - bool SetRecvCodecs(const std::vector& codecs) { - if (fail_set_recv_codecs()) { - // Fake the failure in SetRecvCodecs. - return false; - } - recv_codecs_ = codecs; - return true; - } - bool SetSendCodecs(const std::vector& codecs) { - if (fail_set_send_codecs()) { - // Fake the failure in SetSendCodecs. - return false; - } - send_codecs_ = codecs; - return true; - } - bool SetMaxSendBandwidth(int bps) { - max_bps_ = bps; - return true; - } - bool SetOptions(const AudioOptions& options) { - // Does a "merge" of current options and set options. - options_.SetAll(options); - return true; - } - bool SetLocalSource(uint32_t ssrc, AudioSource* source) { - auto it = local_sinks_.find(ssrc); - if (source) { - if (it != local_sinks_.end()) { - RTC_CHECK(it->second->source() == source); - } else { - local_sinks_.insert(std::make_pair( - ssrc, absl::make_unique(source))); - } - } else { - if (it != local_sinks_.end()) { - local_sinks_.erase(it); - } - } - return true; - } + bool SetRecvCodecs(const std::vector& codecs); + bool SetSendCodecs(const std::vector& codecs); + bool SetMaxSendBandwidth(int bps); + bool SetOptions(const AudioOptions& options); + bool SetLocalSource(uint32_t ssrc, AudioSource* source); FakeVoiceEngine* engine_; std::vector recv_codecs_; @@ -506,136 +387,55 @@ class FakeVoiceMediaChannel : public RtpHelper { }; // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo. -inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info, - uint32_t ssrc, - int event_code, - int duration) { - return (info.duration == duration && info.event_code == event_code && - info.ssrc == ssrc); -} +bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info, + uint32_t ssrc, + int event_code, + int duration); class FakeVideoMediaChannel : public RtpHelper { public: - FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options) - : engine_(engine), max_bps_(-1) { - SetOptions(options); - } + FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options); ~FakeVideoMediaChannel(); - const std::vector& recv_codecs() const { return recv_codecs_; } - const std::vector& send_codecs() const { return send_codecs_; } - const std::vector& codecs() const { return send_codecs(); } - bool rendering() const { return playout(); } - const VideoOptions& options() const { return options_; } + const std::vector& recv_codecs() const; + const std::vector& send_codecs() const; + const std::vector& codecs() const; + bool rendering() const; + const VideoOptions& options() const; const std::map*>& - sinks() const { - return sinks_; - } - int max_bps() const { return max_bps_; } - bool SetSendParameters(const VideoSendParameters& params) override { - set_send_rtcp_parameters(params.rtcp); - return (SetSendCodecs(params.codecs) && - SetSendRtpHeaderExtensions(params.extensions) && - SetMaxSendBandwidth(params.max_bandwidth_bps)); - } - bool SetRecvParameters(const VideoRecvParameters& params) override { - set_recv_rtcp_parameters(params.rtcp); - return (SetRecvCodecs(params.codecs) && - SetRecvRtpHeaderExtensions(params.extensions)); - } - bool AddSendStream(const StreamParams& sp) override { - return RtpHelper::AddSendStream(sp); - } - bool RemoveSendStream(uint32_t ssrc) override { - return RtpHelper::RemoveSendStream(ssrc); - } + sinks() const; + int max_bps() const; + bool SetSendParameters(const VideoSendParameters& params) override; + bool SetRecvParameters(const VideoRecvParameters& params) override; + bool AddSendStream(const StreamParams& sp) override; + bool RemoveSendStream(uint32_t ssrc) override; - bool GetSendCodec(VideoCodec* send_codec) override { - if (send_codecs_.empty()) { - return false; - } - *send_codec = send_codecs_[0]; - return true; - } + bool GetSendCodec(VideoCodec* send_codec) override; bool SetSink(uint32_t ssrc, - rtc::VideoSinkInterface* sink) override { - if (ssrc != 0 && sinks_.find(ssrc) == sinks_.end()) { - return false; - } - if (ssrc != 0) { - sinks_[ssrc] = sink; - } - return true; - } - bool HasSink(uint32_t ssrc) const { - return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr; - } + rtc::VideoSinkInterface* sink) override; + bool HasSink(uint32_t ssrc) const; - bool SetSend(bool send) override { return set_sending(send); } + bool SetSend(bool send) override; bool SetVideoSend( uint32_t ssrc, const VideoOptions* options, - rtc::VideoSourceInterface* source) override { - if (options) { - if (!SetOptions(*options)) { - return false; - } - } - sources_[ssrc] = source; - return true; - } + rtc::VideoSourceInterface* source) override; - bool HasSource(uint32_t ssrc) const { - return sources_.find(ssrc) != sources_.end() && - sources_.at(ssrc) != nullptr; - } - bool AddRecvStream(const StreamParams& sp) override { - if (!RtpHelper::AddRecvStream(sp)) - return false; - sinks_[sp.first_ssrc()] = NULL; - return true; - } - bool RemoveRecvStream(uint32_t ssrc) override { - if (!RtpHelper::RemoveRecvStream(ssrc)) - return false; - sinks_.erase(ssrc); - return true; - } + bool HasSource(uint32_t ssrc) const; + bool AddRecvStream(const StreamParams& sp) override; + bool RemoveRecvStream(uint32_t ssrc) override; - void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override {} - bool GetStats(VideoMediaInfo* info) override { return false; } + void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override; + bool GetStats(VideoMediaInfo* info) override; - std::vector GetSources(uint32_t ssrc) const override { - return {}; - } + std::vector GetSources(uint32_t ssrc) const override; private: - bool SetRecvCodecs(const std::vector& codecs) { - if (fail_set_recv_codecs()) { - // Fake the failure in SetRecvCodecs. - return false; - } - recv_codecs_ = codecs; - return true; - } - bool SetSendCodecs(const std::vector& codecs) { - if (fail_set_send_codecs()) { - // Fake the failure in SetSendCodecs. - return false; - } - send_codecs_ = codecs; - - return true; - } - bool SetOptions(const VideoOptions& options) { - options_ = options; - return true; - } - bool SetMaxSendBandwidth(int bps) { - max_bps_ = bps; - return true; - } + bool SetRecvCodecs(const std::vector& codecs); + bool SetSendCodecs(const std::vector& codecs); + bool SetOptions(const VideoOptions& options); + bool SetMaxSendBandwidth(int bps); FakeVideoEngine* engine_; std::vector recv_codecs_; @@ -652,78 +452,33 @@ class DataOptions {}; class FakeDataMediaChannel : public RtpHelper { public: - explicit FakeDataMediaChannel(void* unused, const DataOptions& options) - : send_blocked_(false), max_bps_(-1) {} - ~FakeDataMediaChannel() {} - const std::vector& recv_codecs() const { return recv_codecs_; } - const std::vector& send_codecs() const { return send_codecs_; } - const std::vector& codecs() const { return send_codecs(); } - int max_bps() const { return max_bps_; } + explicit FakeDataMediaChannel(void* unused, const DataOptions& options); + ~FakeDataMediaChannel(); + const std::vector& recv_codecs() const; + const std::vector& send_codecs() const; + const std::vector& codecs() const; + int max_bps() const; - virtual bool SetSendParameters(const DataSendParameters& params) { - set_send_rtcp_parameters(params.rtcp); - return (SetSendCodecs(params.codecs) && - SetMaxSendBandwidth(params.max_bandwidth_bps)); - } - virtual bool SetRecvParameters(const DataRecvParameters& params) { - set_recv_rtcp_parameters(params.rtcp); - return SetRecvCodecs(params.codecs); - } - virtual bool SetSend(bool send) { return set_sending(send); } - virtual bool SetReceive(bool receive) { - set_playout(receive); - return true; - } - virtual bool AddRecvStream(const StreamParams& sp) { - if (!RtpHelper::AddRecvStream(sp)) - return false; - return true; - } - virtual bool RemoveRecvStream(uint32_t ssrc) { - if (!RtpHelper::RemoveRecvStream(ssrc)) - return false; - return true; - } + bool SetSendParameters(const DataSendParameters& params) override; + bool SetRecvParameters(const DataRecvParameters& params) override; + bool SetSend(bool send) override; + bool SetReceive(bool receive) override; + bool AddRecvStream(const StreamParams& sp) override; + bool RemoveRecvStream(uint32_t ssrc) override; - virtual bool SendData(const SendDataParams& params, - const rtc::CopyOnWriteBuffer& payload, - SendDataResult* result) { - if (send_blocked_) { - *result = SDR_BLOCK; - return false; - } else { - last_sent_data_params_ = params; - last_sent_data_ = std::string(payload.data(), payload.size()); - return true; - } - } + bool SendData(const SendDataParams& params, + const rtc::CopyOnWriteBuffer& payload, + SendDataResult* result) override; - SendDataParams last_sent_data_params() { return last_sent_data_params_; } - std::string last_sent_data() { return last_sent_data_; } - bool is_send_blocked() { return send_blocked_; } - void set_send_blocked(bool blocked) { send_blocked_ = blocked; } + SendDataParams last_sent_data_params(); + std::string last_sent_data(); + bool is_send_blocked(); + void set_send_blocked(bool blocked); private: - bool SetRecvCodecs(const std::vector& codecs) { - if (fail_set_recv_codecs()) { - // Fake the failure in SetRecvCodecs. - return false; - } - recv_codecs_ = codecs; - return true; - } - bool SetSendCodecs(const std::vector& codecs) { - if (fail_set_send_codecs()) { - // Fake the failure in SetSendCodecs. - return false; - } - send_codecs_ = codecs; - return true; - } - bool SetMaxSendBandwidth(int bps) { - max_bps_ = bps; - return true; - } + bool SetRecvCodecs(const std::vector& codecs); + bool SetSendCodecs(const std::vector& codecs); + bool SetMaxSendBandwidth(int bps); std::vector recv_codecs_; std::vector send_codecs_; @@ -737,23 +492,11 @@ class FakeDataMediaChannel : public RtpHelper { // and FakeVideoEngine. class FakeBaseEngine { public: - FakeBaseEngine() : options_changed_(false), fail_create_channel_(false) {} - void set_fail_create_channel(bool fail) { fail_create_channel_ = fail; } - - RtpCapabilities GetCapabilities() const { return capabilities_; } - void set_rtp_header_extensions(const std::vector& extensions) { - capabilities_.header_extensions = extensions; - } - + FakeBaseEngine(); + void set_fail_create_channel(bool fail); + void set_rtp_header_extensions(const std::vector& extensions); void set_rtp_header_extensions( - const std::vector& extensions) { - for (const cricket::RtpHeaderExtension& ext : extensions) { - RtpExtension webrtc_ext; - webrtc_ext.uri = ext.uri; - webrtc_ext.id = ext.id; - capabilities_.header_extensions.push_back(webrtc_ext); - } - } + const std::vector& extensions); protected: // Flag used by optionsmessagehandler_unittest for checking whether any @@ -766,55 +509,28 @@ class FakeBaseEngine { class FakeVoiceEngine : public FakeBaseEngine { public: - FakeVoiceEngine() { - // Add a fake audio codec. Note that the name must not be "" as there are - // sanity checks against that. - codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1)); - } - void Init() {} - rtc::scoped_refptr GetAudioState() const { - return rtc::scoped_refptr(); - } + FakeVoiceEngine(); + RtpCapabilities GetCapabilities() const; + void Init(); + rtc::scoped_refptr GetAudioState() const; - VoiceMediaChannel* CreateChannel( - webrtc::Call* call, - const MediaConfig& config, - const AudioOptions& options, - const webrtc::CryptoOptions& crypto_options) { - if (fail_create_channel_) { - return nullptr; - } - - FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this, options); - channels_.push_back(ch); - return ch; - } - FakeVoiceMediaChannel* GetChannel(size_t index) { - return (channels_.size() > index) ? channels_[index] : NULL; - } - void UnregisterChannel(VoiceMediaChannel* channel) { - channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); - } + VoiceMediaChannel* CreateChannel(webrtc::Call* call, + const MediaConfig& config, + const AudioOptions& options, + const webrtc::CryptoOptions& crypto_options); + FakeVoiceMediaChannel* GetChannel(size_t index); + void UnregisterChannel(VoiceMediaChannel* channel); // TODO(ossu): For proper testing, These should either individually settable // or the voice engine should reference mockable factories. - const std::vector& send_codecs() { return codecs_; } - const std::vector& recv_codecs() { return codecs_; } - void SetCodecs(const std::vector& codecs) { codecs_ = codecs; } - - int GetInputLevel() { return 0; } - - bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) { - return false; - } - - void StopAecDump() {} - - bool StartRtcEventLog(rtc::PlatformFile file, int64_t max_size_bytes) { - return false; - } - - void StopRtcEventLog() {} + const std::vector& send_codecs() const; + const std::vector& recv_codecs() const; + void SetCodecs(const std::vector& codecs); + int GetInputLevel(); + bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes); + void StopAecDump(); + bool StartRtcEventLog(rtc::PlatformFile file, int64_t max_size_bytes); + void StopRtcEventLog(); private: std::vector channels_; @@ -825,49 +541,18 @@ class FakeVoiceEngine : public FakeBaseEngine { class FakeVideoEngine : public FakeBaseEngine { public: - FakeVideoEngine() : capture_(false) { - // Add a fake video codec. Note that the name must not be "" as there are - // sanity checks against that. - codecs_.push_back(VideoCodec(0, "fake_video_codec")); - } - - bool SetOptions(const VideoOptions& options) { - options_ = options; - options_changed_ = true; - return true; - } - + FakeVideoEngine(); + RtpCapabilities GetCapabilities() const; + bool SetOptions(const VideoOptions& options); VideoMediaChannel* CreateChannel(webrtc::Call* call, const MediaConfig& config, const VideoOptions& options, - const webrtc::CryptoOptions crypto_options) { - if (fail_create_channel_) { - return nullptr; - } - - FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options); - channels_.emplace_back(ch); - return ch; - } - - FakeVideoMediaChannel* GetChannel(size_t index) { - return (channels_.size() > index) ? channels_[index] : nullptr; - } - - void UnregisterChannel(VideoMediaChannel* channel) { - auto it = std::find(channels_.begin(), channels_.end(), channel); - RTC_DCHECK(it != channels_.end()); - channels_.erase(it); - } - - const std::vector& codecs() const { return codecs_; } - - void SetCodecs(const std::vector codecs) { codecs_ = codecs; } - - bool SetCapture(bool capture) { - capture_ = capture; - return true; - } + const webrtc::CryptoOptions& crypto_options); + FakeVideoMediaChannel* GetChannel(size_t index); + void UnregisterChannel(VideoMediaChannel* channel); + std::vector codecs() const; + void SetCodecs(const std::vector codecs); + bool SetCapture(bool capture); private: std::vector channels_; @@ -881,88 +566,47 @@ class FakeVideoEngine : public FakeBaseEngine { class FakeMediaEngine : public CompositeMediaEngine { public: - FakeMediaEngine() - : CompositeMediaEngine(std::tuple<>(), - std::tuple<>()) { - } + FakeMediaEngine(); - virtual ~FakeMediaEngine() {} + ~FakeMediaEngine() override; - void SetAudioCodecs(const std::vector& codecs) { - voice().SetCodecs(codecs); - } - void SetVideoCodecs(const std::vector& codecs) { - video().SetCodecs(codecs); - } + void SetAudioCodecs(const std::vector& codecs); + void SetVideoCodecs(const std::vector& codecs); + + void SetAudioRtpHeaderExtensions(const std::vector& extensions); + void SetVideoRtpHeaderExtensions(const std::vector& extensions); void SetAudioRtpHeaderExtensions( - const std::vector& extensions) { - voice().set_rtp_header_extensions(extensions); - } + const std::vector& extensions); void SetVideoRtpHeaderExtensions( - const std::vector& extensions) { - video().set_rtp_header_extensions(extensions); - } + const std::vector& extensions); - void SetAudioRtpHeaderExtensions( - const std::vector& extensions) { - voice().set_rtp_header_extensions(extensions); - } - void SetVideoRtpHeaderExtensions( - const std::vector& extensions) { - video().set_rtp_header_extensions(extensions); - } + FakeVoiceMediaChannel* GetVoiceChannel(size_t index); + FakeVideoMediaChannel* GetVideoChannel(size_t index); - FakeVoiceMediaChannel* GetVoiceChannel(size_t index) { - return voice().GetChannel(index); - } - FakeVideoMediaChannel* GetVideoChannel(size_t index) { - return video().GetChannel(index); - } + bool capture() const; + bool options_changed() const; + void clear_options_changed(); + void set_fail_create_channel(bool fail); - bool capture() const { return video().capture_; } - bool options_changed() const { return video().options_changed_; } - void clear_options_changed() { video().options_changed_ = false; } - void set_fail_create_channel(bool fail) { - voice().set_fail_create_channel(fail); - video().set_fail_create_channel(fail); - } + private: + FakeVoiceEngine* const voice_; + FakeVideoEngine* const video_; }; // Have to come afterwards due to declaration order -inline FakeVoiceMediaChannel::~FakeVoiceMediaChannel() { - if (engine_) { - engine_->UnregisterChannel(this); - } -} - -inline FakeVideoMediaChannel::~FakeVideoMediaChannel() { - if (engine_) { - engine_->UnregisterChannel(this); - } -} class FakeDataEngine : public DataEngineInterface { public: - virtual DataMediaChannel* CreateChannel(const MediaConfig& config) { - FakeDataMediaChannel* ch = new FakeDataMediaChannel(this, DataOptions()); - channels_.push_back(ch); - return ch; - } + DataMediaChannel* CreateChannel(const MediaConfig& config) override; - FakeDataMediaChannel* GetChannel(size_t index) { - return (channels_.size() > index) ? channels_[index] : NULL; - } + FakeDataMediaChannel* GetChannel(size_t index); - void UnregisterChannel(DataMediaChannel* channel) { - channels_.erase(std::find(channels_.begin(), channels_.end(), channel)); - } + void UnregisterChannel(DataMediaChannel* channel); - virtual void SetDataCodecs(const std::vector& data_codecs) { - data_codecs_ = data_codecs; - } + void SetDataCodecs(const std::vector& data_codecs); - virtual const std::vector& data_codecs() { return data_codecs_; } + const std::vector& data_codecs() override; private: std::vector channels_;