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 <nisse@webrtc.org> Commit-Queue: Sebastian Jansson <srte@webrtc.org> Cr-Commit-Position: refs/heads/master@{#25260}
This commit is contained in:
Sebastian Jansson
Commit Bot
parent
7dc97740ea
commit
cb06cac5b4
@ -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",
|
||||
|
||||
637
media/base/fakemediaengine.cc
Normal file
637
media/base/fakemediaengine.cc
Normal file
@ -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 <utility>
|
||||
|
||||
#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<AudioCodec>& FakeVoiceMediaChannel::recv_codecs() const {
|
||||
return recv_codecs_;
|
||||
}
|
||||
const std::vector<AudioCodec>& FakeVoiceMediaChannel::send_codecs() const {
|
||||
return send_codecs_;
|
||||
}
|
||||
const std::vector<AudioCodec>& FakeVoiceMediaChannel::codecs() const {
|
||||
return send_codecs();
|
||||
}
|
||||
const std::vector<FakeVoiceMediaChannel::DtmfInfo>&
|
||||
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<VoiceMediaChannel>::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<VoiceMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
output_scalings_[sp.first_ssrc()] = 1.0;
|
||||
return true;
|
||||
}
|
||||
bool FakeVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
|
||||
if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
|
||||
return false;
|
||||
output_scalings_.erase(ssrc);
|
||||
return true;
|
||||
}
|
||||
bool FakeVoiceMediaChannel::CanInsertDtmf() {
|
||||
for (std::vector<AudioCodec>::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<uint32_t, double>::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<webrtc::AudioSinkInterface> sink) {
|
||||
sink_ = std::move(sink);
|
||||
}
|
||||
std::vector<webrtc::RtpSource> FakeVoiceMediaChannel::GetSources(
|
||||
uint32_t ssrc) const {
|
||||
return std::vector<webrtc::RtpSource>();
|
||||
}
|
||||
bool FakeVoiceMediaChannel::SetRecvCodecs(
|
||||
const std::vector<AudioCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool FakeVoiceMediaChannel::SetSendCodecs(
|
||||
const std::vector<AudioCodec>& 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<VoiceChannelAudioSink>(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<VideoCodec>& FakeVideoMediaChannel::recv_codecs() const {
|
||||
return recv_codecs_;
|
||||
}
|
||||
const std::vector<VideoCodec>& FakeVideoMediaChannel::send_codecs() const {
|
||||
return send_codecs_;
|
||||
}
|
||||
const std::vector<VideoCodec>& FakeVideoMediaChannel::codecs() const {
|
||||
return send_codecs();
|
||||
}
|
||||
bool FakeVideoMediaChannel::rendering() const {
|
||||
return playout();
|
||||
}
|
||||
const VideoOptions& FakeVideoMediaChannel::options() const {
|
||||
return options_;
|
||||
}
|
||||
const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
|
||||
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<VideoMediaChannel>::AddSendStream(sp);
|
||||
}
|
||||
bool FakeVideoMediaChannel::RemoveSendStream(uint32_t ssrc) {
|
||||
return RtpHelper<VideoMediaChannel>::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<webrtc::VideoFrame>* 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<webrtc::VideoFrame>* 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<VideoMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
sinks_[sp.first_ssrc()] = NULL;
|
||||
return true;
|
||||
}
|
||||
bool FakeVideoMediaChannel::RemoveRecvStream(uint32_t ssrc) {
|
||||
if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
|
||||
return false;
|
||||
sinks_.erase(ssrc);
|
||||
return true;
|
||||
}
|
||||
void FakeVideoMediaChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
|
||||
}
|
||||
bool FakeVideoMediaChannel::GetStats(VideoMediaInfo* info) {
|
||||
return false;
|
||||
}
|
||||
std::vector<webrtc::RtpSource> FakeVideoMediaChannel::GetSources(
|
||||
uint32_t ssrc) const {
|
||||
return {};
|
||||
}
|
||||
bool FakeVideoMediaChannel::SetRecvCodecs(
|
||||
const std::vector<VideoCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool FakeVideoMediaChannel::SetSendCodecs(
|
||||
const std::vector<VideoCodec>& 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<DataCodec>& FakeDataMediaChannel::recv_codecs() const {
|
||||
return recv_codecs_;
|
||||
}
|
||||
const std::vector<DataCodec>& FakeDataMediaChannel::send_codecs() const {
|
||||
return send_codecs_;
|
||||
}
|
||||
const std::vector<DataCodec>& 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<DataMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
bool FakeDataMediaChannel::RemoveRecvStream(uint32_t ssrc) {
|
||||
if (!RtpHelper<DataMediaChannel>::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<char>(), 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<DataCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool FakeDataMediaChannel::SetSendCodecs(const std::vector<DataCodec>& 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<webrtc::RtpExtension>& extensions) {
|
||||
capabilities_.header_extensions = extensions;
|
||||
}
|
||||
void FakeBaseEngine::set_rtp_header_extensions(
|
||||
const std::vector<RtpHeaderExtension>& 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<webrtc::AudioState> FakeVoiceEngine::GetAudioState() const {
|
||||
return rtc::scoped_refptr<webrtc::AudioState>();
|
||||
}
|
||||
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<AudioCodec>& FakeVoiceEngine::send_codecs() const {
|
||||
return codecs_;
|
||||
}
|
||||
const std::vector<AudioCodec>& FakeVoiceEngine::recv_codecs() const {
|
||||
return codecs_;
|
||||
}
|
||||
void FakeVoiceEngine::SetCodecs(const std::vector<AudioCodec>& 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<VideoCodec> FakeVideoEngine::codecs() const {
|
||||
return codecs_;
|
||||
}
|
||||
void FakeVideoEngine::SetCodecs(const std::vector<VideoCodec> codecs) {
|
||||
codecs_ = codecs;
|
||||
}
|
||||
bool FakeVideoEngine::SetCapture(bool capture) {
|
||||
capture_ = capture;
|
||||
return true;
|
||||
}
|
||||
|
||||
FakeMediaEngine::FakeMediaEngine()
|
||||
: CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(std::tuple<>(),
|
||||
std::tuple<>()),
|
||||
voice_(&voice()),
|
||||
video_(&video()) {}
|
||||
FakeMediaEngine::~FakeMediaEngine() {}
|
||||
void FakeMediaEngine::SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
|
||||
voice_->SetCodecs(codecs);
|
||||
}
|
||||
void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
|
||||
video_->SetCodecs(codecs);
|
||||
}
|
||||
void FakeMediaEngine::SetAudioRtpHeaderExtensions(
|
||||
const std::vector<webrtc::RtpExtension>& extensions) {
|
||||
voice_->set_rtp_header_extensions(extensions);
|
||||
}
|
||||
void FakeMediaEngine::SetVideoRtpHeaderExtensions(
|
||||
const std::vector<webrtc::RtpExtension>& extensions) {
|
||||
video_->set_rtp_header_extensions(extensions);
|
||||
}
|
||||
void FakeMediaEngine::SetAudioRtpHeaderExtensions(
|
||||
const std::vector<RtpHeaderExtension>& extensions) {
|
||||
voice_->set_rtp_header_extensions(extensions);
|
||||
}
|
||||
void FakeMediaEngine::SetVideoRtpHeaderExtensions(
|
||||
const std::vector<RtpHeaderExtension>& 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<DataCodec>& data_codecs) {
|
||||
data_codecs_ = data_codecs;
|
||||
}
|
||||
const std::vector<DataCodec>& FakeDataEngine::data_codecs() {
|
||||
return data_codecs_;
|
||||
}
|
||||
|
||||
} // namespace cricket
|
||||
@ -17,10 +17,8 @@
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#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<VoiceMediaChannel> {
|
||||
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<AudioCodec>& recv_codecs() const { return recv_codecs_; }
|
||||
const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
|
||||
const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
|
||||
const std::vector<DtmfInfo>& 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<AudioCodec>& recv_codecs() const;
|
||||
const std::vector<AudioCodec>& send_codecs() const;
|
||||
const std::vector<AudioCodec>& codecs() const;
|
||||
const std::vector<DtmfInfo>& 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<VoiceMediaChannel>::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<VoiceMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
output_scalings_[sp.first_ssrc()] = 1.0;
|
||||
return true;
|
||||
}
|
||||
virtual bool RemoveRecvStream(uint32_t ssrc) {
|
||||
if (!RtpHelper<VoiceMediaChannel>::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<AudioCodec>::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<uint32_t, double>::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<webrtc::AudioSinkInterface> sink) {
|
||||
sink_ = std::move(sink);
|
||||
}
|
||||
std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
|
||||
|
||||
virtual std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const {
|
||||
return std::vector<webrtc::RtpSource>();
|
||||
}
|
||||
std::vector<webrtc::RtpSource> 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<AudioCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool SetSendCodecs(const std::vector<AudioCodec>& 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<VoiceChannelAudioSink>(source)));
|
||||
}
|
||||
} else {
|
||||
if (it != local_sinks_.end()) {
|
||||
local_sinks_.erase(it);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
|
||||
bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
|
||||
bool SetMaxSendBandwidth(int bps);
|
||||
bool SetOptions(const AudioOptions& options);
|
||||
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
|
||||
|
||||
FakeVoiceEngine* engine_;
|
||||
std::vector<AudioCodec> recv_codecs_;
|
||||
@ -506,136 +387,55 @@ class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
|
||||
};
|
||||
|
||||
// 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<VideoMediaChannel> {
|
||||
public:
|
||||
FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options)
|
||||
: engine_(engine), max_bps_(-1) {
|
||||
SetOptions(options);
|
||||
}
|
||||
FakeVideoMediaChannel(FakeVideoEngine* engine, const VideoOptions& options);
|
||||
|
||||
~FakeVideoMediaChannel();
|
||||
|
||||
const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
|
||||
const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
|
||||
const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
|
||||
bool rendering() const { return playout(); }
|
||||
const VideoOptions& options() const { return options_; }
|
||||
const std::vector<VideoCodec>& recv_codecs() const;
|
||||
const std::vector<VideoCodec>& send_codecs() const;
|
||||
const std::vector<VideoCodec>& codecs() const;
|
||||
bool rendering() const;
|
||||
const VideoOptions& options() const;
|
||||
const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
|
||||
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<VideoMediaChannel>::AddSendStream(sp);
|
||||
}
|
||||
bool RemoveSendStream(uint32_t ssrc) override {
|
||||
return RtpHelper<VideoMediaChannel>::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<webrtc::VideoFrame>* 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<webrtc::VideoFrame>* 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<webrtc::VideoFrame>* source) override {
|
||||
if (options) {
|
||||
if (!SetOptions(*options)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
sources_[ssrc] = source;
|
||||
return true;
|
||||
}
|
||||
rtc::VideoSourceInterface<webrtc::VideoFrame>* 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<VideoMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
sinks_[sp.first_ssrc()] = NULL;
|
||||
return true;
|
||||
}
|
||||
bool RemoveRecvStream(uint32_t ssrc) override {
|
||||
if (!RtpHelper<VideoMediaChannel>::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<webrtc::RtpSource> GetSources(uint32_t ssrc) const override {
|
||||
return {};
|
||||
}
|
||||
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
|
||||
|
||||
private:
|
||||
bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool SetSendCodecs(const std::vector<VideoCodec>& 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<VideoCodec>& codecs);
|
||||
bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
|
||||
bool SetOptions(const VideoOptions& options);
|
||||
bool SetMaxSendBandwidth(int bps);
|
||||
|
||||
FakeVideoEngine* engine_;
|
||||
std::vector<VideoCodec> recv_codecs_;
|
||||
@ -652,78 +452,33 @@ class DataOptions {};
|
||||
|
||||
class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
|
||||
public:
|
||||
explicit FakeDataMediaChannel(void* unused, const DataOptions& options)
|
||||
: send_blocked_(false), max_bps_(-1) {}
|
||||
~FakeDataMediaChannel() {}
|
||||
const std::vector<DataCodec>& recv_codecs() const { return recv_codecs_; }
|
||||
const std::vector<DataCodec>& send_codecs() const { return send_codecs_; }
|
||||
const std::vector<DataCodec>& codecs() const { return send_codecs(); }
|
||||
int max_bps() const { return max_bps_; }
|
||||
explicit FakeDataMediaChannel(void* unused, const DataOptions& options);
|
||||
~FakeDataMediaChannel();
|
||||
const std::vector<DataCodec>& recv_codecs() const;
|
||||
const std::vector<DataCodec>& send_codecs() const;
|
||||
const std::vector<DataCodec>& 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<DataMediaChannel>::AddRecvStream(sp))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
virtual bool RemoveRecvStream(uint32_t ssrc) {
|
||||
if (!RtpHelper<DataMediaChannel>::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<char>(), 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<DataCodec>& codecs) {
|
||||
if (fail_set_recv_codecs()) {
|
||||
// Fake the failure in SetRecvCodecs.
|
||||
return false;
|
||||
}
|
||||
recv_codecs_ = codecs;
|
||||
return true;
|
||||
}
|
||||
bool SetSendCodecs(const std::vector<DataCodec>& 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<DataCodec>& codecs);
|
||||
bool SetSendCodecs(const std::vector<DataCodec>& codecs);
|
||||
bool SetMaxSendBandwidth(int bps);
|
||||
|
||||
std::vector<DataCodec> recv_codecs_;
|
||||
std::vector<DataCodec> send_codecs_;
|
||||
@ -737,23 +492,11 @@ class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
|
||||
// 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<RtpExtension>& extensions) {
|
||||
capabilities_.header_extensions = extensions;
|
||||
}
|
||||
|
||||
FakeBaseEngine();
|
||||
void set_fail_create_channel(bool fail);
|
||||
void set_rtp_header_extensions(const std::vector<RtpExtension>& extensions);
|
||||
void set_rtp_header_extensions(
|
||||
const std::vector<cricket::RtpHeaderExtension>& 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<cricket::RtpHeaderExtension>& 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<webrtc::AudioState> GetAudioState() const {
|
||||
return rtc::scoped_refptr<webrtc::AudioState>();
|
||||
}
|
||||
FakeVoiceEngine();
|
||||
RtpCapabilities GetCapabilities() const;
|
||||
void Init();
|
||||
rtc::scoped_refptr<webrtc::AudioState> 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<AudioCodec>& send_codecs() { return codecs_; }
|
||||
const std::vector<AudioCodec>& recv_codecs() { return codecs_; }
|
||||
void SetCodecs(const std::vector<AudioCodec>& 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<AudioCodec>& send_codecs() const;
|
||||
const std::vector<AudioCodec>& recv_codecs() const;
|
||||
void SetCodecs(const std::vector<AudioCodec>& 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<FakeVoiceMediaChannel*> 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<VideoCodec>& codecs() const { return codecs_; }
|
||||
|
||||
void SetCodecs(const std::vector<VideoCodec> 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<VideoCodec> codecs() const;
|
||||
void SetCodecs(const std::vector<VideoCodec> codecs);
|
||||
bool SetCapture(bool capture);
|
||||
|
||||
private:
|
||||
std::vector<FakeVideoMediaChannel*> channels_;
|
||||
@ -881,88 +566,47 @@ class FakeVideoEngine : public FakeBaseEngine {
|
||||
class FakeMediaEngine
|
||||
: public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
|
||||
public:
|
||||
FakeMediaEngine()
|
||||
: CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(std::tuple<>(),
|
||||
std::tuple<>()) {
|
||||
}
|
||||
FakeMediaEngine();
|
||||
|
||||
virtual ~FakeMediaEngine() {}
|
||||
~FakeMediaEngine() override;
|
||||
|
||||
void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
|
||||
voice().SetCodecs(codecs);
|
||||
}
|
||||
void SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
|
||||
video().SetCodecs(codecs);
|
||||
}
|
||||
void SetAudioCodecs(const std::vector<AudioCodec>& codecs);
|
||||
void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
|
||||
|
||||
void SetAudioRtpHeaderExtensions(const std::vector<RtpExtension>& extensions);
|
||||
void SetVideoRtpHeaderExtensions(const std::vector<RtpExtension>& extensions);
|
||||
|
||||
void SetAudioRtpHeaderExtensions(
|
||||
const std::vector<RtpExtension>& extensions) {
|
||||
voice().set_rtp_header_extensions(extensions);
|
||||
}
|
||||
const std::vector<cricket::RtpHeaderExtension>& extensions);
|
||||
void SetVideoRtpHeaderExtensions(
|
||||
const std::vector<RtpExtension>& extensions) {
|
||||
video().set_rtp_header_extensions(extensions);
|
||||
}
|
||||
const std::vector<cricket::RtpHeaderExtension>& extensions);
|
||||
|
||||
void SetAudioRtpHeaderExtensions(
|
||||
const std::vector<cricket::RtpHeaderExtension>& extensions) {
|
||||
voice().set_rtp_header_extensions(extensions);
|
||||
}
|
||||
void SetVideoRtpHeaderExtensions(
|
||||
const std::vector<cricket::RtpHeaderExtension>& 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<DataCodec>& data_codecs) {
|
||||
data_codecs_ = data_codecs;
|
||||
}
|
||||
void SetDataCodecs(const std::vector<DataCodec>& data_codecs);
|
||||
|
||||
virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; }
|
||||
const std::vector<DataCodec>& data_codecs() override;
|
||||
|
||||
private:
|
||||
std::vector<FakeDataMediaChannel*> channels_;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user