Split fake media channel classes
This allows to remove some calls to CreateMediaChannel
in the RtpTransceiver code.
This removes the fake engines owning the channels and moves
the responsibility to the tests themselves as it's quite
hard to both return a unique_ptr to a channel and still own it.
The various channel getters from the fake engine are thus
also removed and tests updated accordingly, the channel is
retrieved from internal structs in the tests by going
through the RtpTransceiver objects as it's not possible to
safely get the channels from only a sender or receiver.
As some tests are running in both PlanB and Unified Plan,
getting a transceiver is not working for PlanB. As PlanB
has been deprecated and will eventually be removed,
the problematic tests have either been removed or updated
to only run with Unified Plan.
Bug: webrtc:13931
Change-Id: I0571beca8b9ef2f2089d500802b7b124268d9de3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/310340
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Florent Castelli <orphis@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40366}
diff --git a/media/BUILD.gn b/media/BUILD.gn
index dd698af..3ecc881 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -737,6 +737,7 @@
deps = [
":codec",
":media_channel",
+ ":media_channel_impl",
":media_constants",
":rtc_audio_video",
":rtc_internal_video_codecs",
@@ -747,6 +748,7 @@
":stream_params",
"../api:call_api",
"../api:fec_controller_api",
+ "../api:rtp_parameters",
"../api:scoped_refptr",
"../api/task_queue",
"../api/task_queue:pending_task_safety_flag",
@@ -790,6 +792,7 @@
]
absl_deps = [
"//third_party/abseil-cpp/absl/algorithm:container",
+ "//third_party/abseil-cpp/absl/functional:any_invocable",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc
index e31ffad..02d94aa 100644
--- a/media/base/fake_media_engine.cc
+++ b/media/base/fake_media_engine.cc
@@ -16,109 +16,246 @@
#include "absl/algorithm/container.h"
#include "absl/strings/match.h"
#include "absl/types/optional.h"
+#include "media/base/media_channel.h"
#include "rtc_base/checks.h"
namespace cricket {
using webrtc::TaskQueueBase;
-FakeVoiceMediaChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
- int event_code,
- int duration)
+FakeVoiceMediaReceiveChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
+ int event_code,
+ int duration)
: ssrc(ssrc), event_code(event_code), duration(duration) {}
-FakeVoiceMediaChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
+FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
AudioSource* source)
: source_(source) {
source_->SetSink(this);
}
-FakeVoiceMediaChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
+FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
if (source_) {
source_->SetSink(nullptr);
}
}
-void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnData(
+void FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::OnData(
const void* audio_data,
int bits_per_sample,
int sample_rate,
size_t number_of_channels,
size_t number_of_frames,
absl::optional<int64_t> absolute_capture_timestamp_ms) {}
-void FakeVoiceMediaChannel::VoiceChannelAudioSink::OnClose() {
+void FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::OnClose() {
source_ = nullptr;
}
-AudioSource* FakeVoiceMediaChannel::VoiceChannelAudioSink::source() const {
+AudioSource* FakeVoiceMediaReceiveChannel::VoiceChannelAudioSink::source()
+ const {
return source_;
}
-FakeVoiceMediaChannel::FakeVoiceMediaChannel(MediaChannel::Role role,
- FakeVoiceEngine* engine,
- const AudioOptions& options,
- TaskQueueBase* network_thread)
- : RtpHelper<VoiceMediaChannel>(role, network_thread),
- engine_(engine),
+FakeVoiceMediaReceiveChannel::FakeVoiceMediaReceiveChannel(
+ const AudioOptions& options,
+ TaskQueueBase* network_thread)
+ : RtpReceiveChannelHelper<VoiceMediaReceiveChannelInterface>(
+ network_thread),
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 {
+FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default;
+const std::vector<AudioCodec>& FakeVoiceMediaReceiveChannel::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();
-}
-absl::optional<Codec> FakeVoiceMediaChannel::GetSendCodec() const {
- if (!send_codecs_.empty()) {
- return send_codecs_.front();
- }
- return absl::nullopt;
-}
-const std::vector<FakeVoiceMediaChannel::DtmfInfo>&
-FakeVoiceMediaChannel::dtmf_info_queue() const {
+const std::vector<FakeVoiceMediaReceiveChannel::DtmfInfo>&
+FakeVoiceMediaReceiveChannel::dtmf_info_queue() const {
return dtmf_info_queue_;
}
-const AudioOptions& FakeVoiceMediaChannel::options() const {
+const AudioOptions& FakeVoiceMediaReceiveChannel::options() const {
return options_;
}
-int FakeVoiceMediaChannel::max_bps() const {
+int FakeVoiceMediaReceiveChannel::max_bps() const {
return max_bps_;
}
-bool FakeVoiceMediaChannel::SetSendParameters(
- const AudioSendParameters& params) {
- set_send_rtcp_parameters(params.rtcp);
- return (SetSendCodecs(params.codecs) &&
- SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
- SetSendRtpHeaderExtensions(params.extensions) &&
- SetMaxSendBandwidth(params.max_bandwidth_bps) &&
- SetOptions(params.options));
-}
-bool FakeVoiceMediaChannel::SetRecvParameters(
+bool FakeVoiceMediaReceiveChannel::SetRecvParameters(
const AudioRecvParameters& params) {
set_recv_rtcp_parameters(params.rtcp);
return (SetRecvCodecs(params.codecs) &&
SetRecvRtpHeaderExtensions(params.extensions));
}
-void FakeVoiceMediaChannel::SetPlayout(bool playout) {
+void FakeVoiceMediaReceiveChannel::SetPlayout(bool playout) {
set_playout(playout);
}
-void FakeVoiceMediaChannel::SetSend(bool send) {
+bool FakeVoiceMediaReceiveChannel::HasSource(uint32_t ssrc) const {
+ return local_sinks_.find(ssrc) != local_sinks_.end();
+}
+bool FakeVoiceMediaReceiveChannel::AddRecvStream(const StreamParams& sp) {
+ if (!RtpReceiveChannelHelper<
+ VoiceMediaReceiveChannelInterface>::AddRecvStream(sp))
+ return false;
+ output_scalings_[sp.first_ssrc()] = 1.0;
+ output_delays_[sp.first_ssrc()] = 0;
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::RemoveRecvStream(uint32_t ssrc) {
+ if (!RtpReceiveChannelHelper<
+ VoiceMediaReceiveChannelInterface>::RemoveRecvStream(ssrc))
+ return false;
+ output_scalings_.erase(ssrc);
+ output_delays_.erase(ssrc);
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetOutputVolume(uint32_t ssrc,
+ double volume) {
+ if (output_scalings_.find(ssrc) != output_scalings_.end()) {
+ output_scalings_[ssrc] = volume;
+ return true;
+ }
+ return false;
+}
+bool FakeVoiceMediaReceiveChannel::SetDefaultOutputVolume(double volume) {
+ for (auto& entry : output_scalings_) {
+ entry.second = volume;
+ }
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::GetOutputVolume(uint32_t ssrc,
+ double* volume) {
+ if (output_scalings_.find(ssrc) == output_scalings_.end())
+ return false;
+ *volume = output_scalings_[ssrc];
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
+ int delay_ms) {
+ if (output_delays_.find(ssrc) == output_delays_.end()) {
+ return false;
+ } else {
+ output_delays_[ssrc] = delay_ms;
+ return true;
+ }
+}
+absl::optional<int> FakeVoiceMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs(
+ uint32_t ssrc) const {
+ const auto it = output_delays_.find(ssrc);
+ if (it != output_delays_.end()) {
+ return it->second;
+ }
+ return absl::nullopt;
+}
+bool FakeVoiceMediaReceiveChannel::GetStats(VoiceMediaReceiveInfo* info,
+ bool get_and_clear_legacy_stats) {
+ return false;
+}
+void FakeVoiceMediaReceiveChannel::SetRawAudioSink(
+ uint32_t ssrc,
+ std::unique_ptr<webrtc::AudioSinkInterface> sink) {
+ sink_ = std::move(sink);
+}
+void FakeVoiceMediaReceiveChannel::SetDefaultRawAudioSink(
+ std::unique_ptr<webrtc::AudioSinkInterface> sink) {
+ sink_ = std::move(sink);
+}
+std::vector<webrtc::RtpSource> FakeVoiceMediaReceiveChannel::GetSources(
+ uint32_t ssrc) const {
+ return std::vector<webrtc::RtpSource>();
+}
+bool FakeVoiceMediaReceiveChannel::SetRecvCodecs(
+ const std::vector<AudioCodec>& codecs) {
+ if (fail_set_recv_codecs()) {
+ // Fake the failure in SetRecvCodecs.
+ return false;
+ }
+ recv_codecs_ = codecs;
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetMaxSendBandwidth(int bps) {
+ max_bps_ = bps;
+ return true;
+}
+bool FakeVoiceMediaReceiveChannel::SetOptions(const AudioOptions& options) {
+ // Does a "merge" of current options and set options.
+ options_.SetAll(options);
+ return true;
+}
+
+FakeVoiceMediaSendChannel::DtmfInfo::DtmfInfo(uint32_t ssrc,
+ int event_code,
+ int duration)
+ : ssrc(ssrc), event_code(event_code), duration(duration) {}
+
+FakeVoiceMediaSendChannel::VoiceChannelAudioSink::VoiceChannelAudioSink(
+ AudioSource* source)
+ : source_(source) {
+ source_->SetSink(this);
+}
+FakeVoiceMediaSendChannel::VoiceChannelAudioSink::~VoiceChannelAudioSink() {
+ if (source_) {
+ source_->SetSink(nullptr);
+ }
+}
+void FakeVoiceMediaSendChannel::VoiceChannelAudioSink::OnData(
+ const void* audio_data,
+ int bits_per_sample,
+ int sample_rate,
+ size_t number_of_channels,
+ size_t number_of_frames,
+ absl::optional<int64_t> absolute_capture_timestamp_ms) {}
+void FakeVoiceMediaSendChannel::VoiceChannelAudioSink::OnClose() {
+ source_ = nullptr;
+}
+AudioSource* FakeVoiceMediaSendChannel::VoiceChannelAudioSink::source() const {
+ return source_;
+}
+
+FakeVoiceMediaSendChannel::FakeVoiceMediaSendChannel(
+ const AudioOptions& options,
+ TaskQueueBase* network_thread)
+ : RtpSendChannelHelper<VoiceMediaSendChannelInterface>(network_thread),
+ max_bps_(-1) {
+ output_scalings_[0] = 1.0; // For default channel.
+ SetOptions(options);
+}
+FakeVoiceMediaSendChannel::~FakeVoiceMediaSendChannel() = default;
+const std::vector<AudioCodec>& FakeVoiceMediaSendChannel::send_codecs() const {
+ return send_codecs_;
+}
+absl::optional<Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
+ if (!send_codecs_.empty()) {
+ return send_codecs_.front();
+ }
+ return absl::nullopt;
+}
+const std::vector<FakeVoiceMediaSendChannel::DtmfInfo>&
+FakeVoiceMediaSendChannel::dtmf_info_queue() const {
+ return dtmf_info_queue_;
+}
+const AudioOptions& FakeVoiceMediaSendChannel::options() const {
+ return options_;
+}
+int FakeVoiceMediaSendChannel::max_bps() const {
+ return max_bps_;
+}
+bool FakeVoiceMediaSendChannel::SetSendParameters(
+ const AudioSendParameters& params) {
+ set_send_rtcp_parameters(params.rtcp);
+ SetExtmapAllowMixed(params.extmap_allow_mixed);
+ return (SetSendCodecs(params.codecs) &&
+ SetSendRtpHeaderExtensions(params.extensions) &&
+ SetMaxSendBandwidth(params.max_bandwidth_bps) &&
+ SetOptions(params.options));
+}
+void FakeVoiceMediaSendChannel::SetSend(bool send) {
set_sending(send);
}
-bool FakeVoiceMediaChannel::SetAudioSend(uint32_t ssrc,
- bool enable,
- const AudioOptions* options,
- AudioSource* source) {
+bool FakeVoiceMediaSendChannel::SetAudioSend(uint32_t ssrc,
+ bool enable,
+ const AudioOptions* options,
+ AudioSource* source) {
if (!SetLocalSource(ssrc, source)) {
return false;
}
- if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) {
+ if (!RtpSendChannelHelper<VoiceMediaSendChannelInterface>::MuteStream(
+ ssrc, !enable)) {
return false;
}
if (enable && options) {
@@ -126,24 +263,10 @@
}
return true;
}
-bool FakeVoiceMediaChannel::HasSource(uint32_t ssrc) const {
+bool FakeVoiceMediaSendChannel::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;
- output_delays_[sp.first_ssrc()] = 0;
- return true;
-}
-bool FakeVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
- if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
- return false;
- output_scalings_.erase(ssrc);
- output_delays_.erase(ssrc);
- return true;
-}
-bool FakeVoiceMediaChannel::CanInsertDtmf() {
+bool FakeVoiceMediaSendChannel::CanInsertDtmf() {
for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
it != send_codecs_.end(); ++it) {
// Find the DTMF telephone event "codec".
@@ -153,78 +276,22 @@
}
return false;
}
-bool FakeVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
- int event_code,
- int duration) {
+bool FakeVoiceMediaSendChannel::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 (output_scalings_.find(ssrc) != output_scalings_.end()) {
- output_scalings_[ssrc] = volume;
- return true;
- }
- return false;
-}
-bool FakeVoiceMediaChannel::SetDefaultOutputVolume(double volume) {
- for (auto& entry : output_scalings_) {
- entry.second = volume;
- }
- return true;
-}
-bool FakeVoiceMediaChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
+bool FakeVoiceMediaSendChannel::GetOutputVolume(uint32_t ssrc, double* volume) {
if (output_scalings_.find(ssrc) == output_scalings_.end())
return false;
*volume = output_scalings_[ssrc];
return true;
}
-bool FakeVoiceMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
- int delay_ms) {
- if (output_delays_.find(ssrc) == output_delays_.end()) {
- return false;
- } else {
- output_delays_[ssrc] = delay_ms;
- return true;
- }
-}
-absl::optional<int> FakeVoiceMediaChannel::GetBaseMinimumPlayoutDelayMs(
- uint32_t ssrc) const {
- const auto it = output_delays_.find(ssrc);
- if (it != output_delays_.end()) {
- return it->second;
- }
- return absl::nullopt;
-}
-bool FakeVoiceMediaChannel::GetSendStats(VoiceMediaSendInfo* info) {
+bool FakeVoiceMediaSendChannel::GetStats(VoiceMediaSendInfo* info) {
return false;
}
-bool FakeVoiceMediaChannel::GetReceiveStats(VoiceMediaReceiveInfo* info,
- bool get_and_clear_legacy_stats) {
- return false;
-}
-void FakeVoiceMediaChannel::SetRawAudioSink(
- uint32_t ssrc,
- std::unique_ptr<webrtc::AudioSinkInterface> sink) {
- sink_ = std::move(sink);
-}
-void FakeVoiceMediaChannel::SetDefaultRawAudioSink(
- 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(
+bool FakeVoiceMediaSendChannel::SetSendCodecs(
const std::vector<AudioCodec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
@@ -233,16 +300,17 @@
send_codecs_ = codecs;
return true;
}
-bool FakeVoiceMediaChannel::SetMaxSendBandwidth(int bps) {
+bool FakeVoiceMediaSendChannel::SetMaxSendBandwidth(int bps) {
max_bps_ = bps;
return true;
}
-bool FakeVoiceMediaChannel::SetOptions(const AudioOptions& options) {
+bool FakeVoiceMediaSendChannel::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) {
+bool FakeVoiceMediaSendChannel::SetLocalSource(uint32_t ssrc,
+ AudioSource* source) {
auto it = local_sinks_.find(ssrc);
if (source) {
if (it != local_sinks_.end()) {
@@ -259,7 +327,7 @@
return true;
}
-bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
+bool CompareDtmfInfo(const FakeVoiceMediaSendChannel::DtmfInfo& info,
uint32_t ssrc,
int event_code,
int duration) {
@@ -267,87 +335,44 @@
info.ssrc == ssrc);
}
-FakeVideoMediaChannel::FakeVideoMediaChannel(MediaChannel::Role role,
- FakeVideoEngine* engine,
- const VideoOptions& options,
- TaskQueueBase* network_thread)
- : RtpHelper<VideoMediaChannel>(role, network_thread),
- engine_(engine),
+FakeVideoMediaSendChannel::FakeVideoMediaSendChannel(
+ const VideoOptions& options,
+ TaskQueueBase* network_thread)
+ : RtpSendChannelHelper<VideoMediaSendChannelInterface>(network_thread),
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 {
+FakeVideoMediaSendChannel::~FakeVideoMediaSendChannel() = default;
+const std::vector<VideoCodec>& FakeVideoMediaSendChannel::send_codecs() const {
return send_codecs_;
}
-const std::vector<VideoCodec>& FakeVideoMediaChannel::codecs() const {
+const std::vector<VideoCodec>& FakeVideoMediaSendChannel::codecs() const {
return send_codecs();
}
-bool FakeVideoMediaChannel::rendering() const {
- return playout();
-}
-const VideoOptions& FakeVideoMediaChannel::options() const {
+const VideoOptions& FakeVideoMediaSendChannel::options() const {
return options_;
}
-const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
-FakeVideoMediaChannel::sinks() const {
- return sinks_;
-}
-int FakeVideoMediaChannel::max_bps() const {
+int FakeVideoMediaSendChannel::max_bps() const {
return max_bps_;
}
-bool FakeVideoMediaChannel::SetSendParameters(
+bool FakeVideoMediaSendChannel::SetSendParameters(
const VideoSendParameters& params) {
set_send_rtcp_parameters(params.rtcp);
+ SetExtmapAllowMixed(params.extmap_allow_mixed);
return (SetSendCodecs(params.codecs) &&
- SetSendExtmapAllowMixed(params.extmap_allow_mixed) &&
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);
-}
-absl::optional<Codec> FakeVideoMediaChannel::GetSendCodec() const {
+absl::optional<Codec> FakeVideoMediaSendChannel::GetSendCodec() const {
if (send_codecs_.empty()) {
return absl::nullopt;
}
return send_codecs_[0];
}
-bool FakeVideoMediaChannel::SetSink(
- uint32_t ssrc,
- rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
- auto it = sinks_.find(ssrc);
- if (it == sinks_.end()) {
- return false;
- }
- it->second = sink;
- return true;
-}
-void FakeVideoMediaChannel::SetDefaultSink(
- rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
-bool FakeVideoMediaChannel::HasSink(uint32_t ssrc) const {
- return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
-}
-bool FakeVideoMediaChannel::SetSend(bool send) {
+bool FakeVideoMediaSendChannel::SetSend(bool send) {
return set_sending(send);
}
-bool FakeVideoMediaChannel::SetVideoSend(
+bool FakeVideoMediaSendChannel::SetVideoSend(
uint32_t ssrc,
const VideoOptions* options,
rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
@@ -359,62 +384,15 @@
sources_[ssrc] = source;
return true;
}
-bool FakeVideoMediaChannel::HasSource(uint32_t ssrc) const {
+bool FakeVideoMediaSendChannel::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;
- output_delays_[sp.first_ssrc()] = 0;
- return true;
-}
-bool FakeVideoMediaChannel::RemoveRecvStream(uint32_t ssrc) {
- if (!RtpHelper<VideoMediaChannel>::RemoveRecvStream(ssrc))
- return false;
- sinks_.erase(ssrc);
- output_delays_.erase(ssrc);
- return true;
-}
-void FakeVideoMediaChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
-}
-bool FakeVideoMediaChannel::GetSendStats(VideoMediaSendInfo* info) {
+void FakeVideoMediaSendChannel::FillBitrateInfo(
+ BandwidthEstimationInfo* bwe_info) {}
+bool FakeVideoMediaSendChannel::GetStats(VideoMediaSendInfo* info) {
return false;
}
-bool FakeVideoMediaChannel::GetReceiveStats(VideoMediaReceiveInfo* info) {
- return false;
-}
-std::vector<webrtc::RtpSource> FakeVideoMediaChannel::GetSources(
- uint32_t ssrc) const {
- return {};
-}
-bool FakeVideoMediaChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
- int delay_ms) {
- if (output_delays_.find(ssrc) == output_delays_.end()) {
- return false;
- } else {
- output_delays_[ssrc] = delay_ms;
- return true;
- }
-}
-absl::optional<int> FakeVideoMediaChannel::GetBaseMinimumPlayoutDelayMs(
- uint32_t ssrc) const {
- const auto it = output_delays_.find(ssrc);
- if (it != output_delays_.end()) {
- return it->second;
- }
- return absl::nullopt;
-}
-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(
+bool FakeVideoMediaSendChannel::SetSendCodecs(
const std::vector<VideoCodec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
@@ -424,27 +402,137 @@
return true;
}
-bool FakeVideoMediaChannel::SetOptions(const VideoOptions& options) {
+bool FakeVideoMediaSendChannel::SetOptions(const VideoOptions& options) {
options_ = options;
return true;
}
-bool FakeVideoMediaChannel::SetMaxSendBandwidth(int bps) {
+bool FakeVideoMediaSendChannel::SetMaxSendBandwidth(int bps) {
+ max_bps_ = bps;
+ return true;
+}
+void FakeVideoMediaSendChannel::GenerateSendKeyFrame(
+ uint32_t ssrc,
+ const std::vector<std::string>& rids) {}
+
+FakeVideoMediaReceiveChannel::FakeVideoMediaReceiveChannel(
+ const VideoOptions& options,
+ TaskQueueBase* network_thread)
+ : RtpReceiveChannelHelper<VideoMediaReceiveChannelInterface>(
+ network_thread),
+ max_bps_(-1) {
+ SetOptions(options);
+}
+FakeVideoMediaReceiveChannel::~FakeVideoMediaReceiveChannel() = default;
+const std::vector<VideoCodec>& FakeVideoMediaReceiveChannel::recv_codecs()
+ const {
+ return recv_codecs_;
+}
+bool FakeVideoMediaReceiveChannel::rendering() const {
+ return playout();
+}
+const VideoOptions& FakeVideoMediaReceiveChannel::options() const {
+ return options_;
+}
+const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
+FakeVideoMediaReceiveChannel::sinks() const {
+ return sinks_;
+}
+int FakeVideoMediaReceiveChannel::max_bps() const {
+ return max_bps_;
+}
+bool FakeVideoMediaReceiveChannel::SetRecvParameters(
+ const VideoRecvParameters& params) {
+ set_recv_rtcp_parameters(params.rtcp);
+ return (SetRecvCodecs(params.codecs) &&
+ SetRecvRtpHeaderExtensions(params.extensions));
+}
+bool FakeVideoMediaReceiveChannel::SetSink(
+ uint32_t ssrc,
+ rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
+ auto it = sinks_.find(ssrc);
+ if (it == sinks_.end()) {
+ return false;
+ }
+ it->second = sink;
+ return true;
+}
+void FakeVideoMediaReceiveChannel::SetDefaultSink(
+ rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {}
+bool FakeVideoMediaReceiveChannel::HasSink(uint32_t ssrc) const {
+ return sinks_.find(ssrc) != sinks_.end() && sinks_.at(ssrc) != nullptr;
+}
+bool FakeVideoMediaReceiveChannel::HasSource(uint32_t ssrc) const {
+ return sources_.find(ssrc) != sources_.end() && sources_.at(ssrc) != nullptr;
+}
+bool FakeVideoMediaReceiveChannel::AddRecvStream(const StreamParams& sp) {
+ if (!RtpReceiveChannelHelper<
+ VideoMediaReceiveChannelInterface>::AddRecvStream(sp))
+ return false;
+ sinks_[sp.first_ssrc()] = NULL;
+ output_delays_[sp.first_ssrc()] = 0;
+ return true;
+}
+bool FakeVideoMediaReceiveChannel::RemoveRecvStream(uint32_t ssrc) {
+ if (!RtpReceiveChannelHelper<
+ VideoMediaReceiveChannelInterface>::RemoveRecvStream(ssrc))
+ return false;
+ sinks_.erase(ssrc);
+ output_delays_.erase(ssrc);
+ return true;
+}
+std::vector<webrtc::RtpSource> FakeVideoMediaReceiveChannel::GetSources(
+ uint32_t ssrc) const {
+ return {};
+}
+bool FakeVideoMediaReceiveChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc,
+ int delay_ms) {
+ if (output_delays_.find(ssrc) == output_delays_.end()) {
+ return false;
+ } else {
+ output_delays_[ssrc] = delay_ms;
+ return true;
+ }
+}
+absl::optional<int> FakeVideoMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs(
+ uint32_t ssrc) const {
+ const auto it = output_delays_.find(ssrc);
+ if (it != output_delays_.end()) {
+ return it->second;
+ }
+ return absl::nullopt;
+}
+bool FakeVideoMediaReceiveChannel::SetRecvCodecs(
+ const std::vector<VideoCodec>& codecs) {
+ if (fail_set_recv_codecs()) {
+ // Fake the failure in SetRecvCodecs.
+ return false;
+ }
+ recv_codecs_ = codecs;
+ return true;
+}
+bool FakeVideoMediaReceiveChannel::SetOptions(const VideoOptions& options) {
+ options_ = options;
+ return true;
+}
+
+bool FakeVideoMediaReceiveChannel::SetMaxSendBandwidth(int bps) {
max_bps_ = bps;
return true;
}
-void FakeVideoMediaChannel::SetRecordableEncodedFrameCallback(
+void FakeVideoMediaReceiveChannel::SetRecordableEncodedFrameCallback(
uint32_t ssrc,
std::function<void(const webrtc::RecordableEncodedFrame&)> callback) {}
-void FakeVideoMediaChannel::ClearRecordableEncodedFrameCallback(uint32_t ssrc) {
-}
+void FakeVideoMediaReceiveChannel::ClearRecordableEncodedFrameCallback(
+ uint32_t ssrc) {}
-void FakeVideoMediaChannel::RequestRecvKeyFrame(uint32_t ssrc) {}
-void FakeVideoMediaChannel::GenerateSendKeyFrame(
- uint32_t ssrc,
- const std::vector<std::string>& rids) {}
+void FakeVideoMediaReceiveChannel::RequestRecvKeyFrame(uint32_t ssrc) {}
+
+bool FakeVideoMediaReceiveChannel::GetStats(VideoMediaReceiveInfo* info) {
+ return false;
+}
FakeVoiceEngine::FakeVoiceEngine() : fail_create_channel_(false) {
// Add a fake audio codec. Note that the name must not be "" as there are
@@ -455,57 +543,29 @@
rtc::scoped_refptr<webrtc::AudioState> FakeVoiceEngine::GetAudioState() const {
return rtc::scoped_refptr<webrtc::AudioState>();
}
-VoiceMediaChannel* FakeVoiceEngine::CreateMediaChannel(
- MediaChannel::Role role,
+std::unique_ptr<VoiceMediaSendChannelInterface>
+FakeVoiceEngine::CreateSendChannel(webrtc::Call* call,
+ const MediaConfig& config,
+ const AudioOptions& options,
+ const webrtc::CryptoOptions& crypto_options,
+ webrtc::AudioCodecPairId codec_pair_id) {
+ std::unique_ptr<FakeVoiceMediaSendChannel> ch =
+ std::make_unique<FakeVoiceMediaSendChannel>(options,
+ call->network_thread());
+ return ch;
+}
+std::unique_ptr<VoiceMediaReceiveChannelInterface>
+FakeVoiceEngine::CreateReceiveChannel(
webrtc::Call* call,
const MediaConfig& config,
const AudioOptions& options,
const webrtc::CryptoOptions& crypto_options,
webrtc::AudioCodecPairId codec_pair_id) {
- if (fail_create_channel_) {
- return nullptr;
- }
-
- FakeVoiceMediaChannel* ch =
- new FakeVoiceMediaChannel(role, this, options, call->network_thread());
- switch (role) {
- case MediaChannel::Role::kSend:
- send_channels_.push_back(ch);
- break;
- case MediaChannel::Role::kReceive:
- receive_channels_.push_back(ch);
- break;
- case MediaChannel::Role::kBoth:
- send_channels_.push_back(ch);
- receive_channels_.push_back(ch);
- break;
- default:
- RTC_CHECK_NOTREACHED();
- }
+ std::unique_ptr<FakeVoiceMediaReceiveChannel> ch =
+ std::make_unique<FakeVoiceMediaReceiveChannel>(options,
+ call->network_thread());
return ch;
}
-FakeVoiceMediaChannel* FakeVoiceEngine::GetSendChannel(size_t index) {
- return (send_channels_.size() > index) ? send_channels_[index] : NULL;
-}
-FakeVoiceMediaChannel* FakeVoiceEngine::GetReceiveChannel(size_t index) {
- return (receive_channels_.size() > index) ? receive_channels_[index] : NULL;
-}
-void FakeVoiceEngine::UnregisterChannel(VoiceMediaChannel* channel) {
- switch (channel->role()) {
- case MediaChannel::Role::kSend:
- send_channels_.erase(absl::c_find(send_channels_, channel));
- break;
- case MediaChannel::Role::kReceive:
- receive_channels_.erase(absl::c_find(receive_channels_, channel));
- break;
- case MediaChannel::Role::kBoth:
- send_channels_.erase(absl::c_find(send_channels_, channel));
- receive_channels_.erase(absl::c_find(receive_channels_, channel));
- break;
- default:
- RTC_CHECK_NOTREACHED();
- }
-}
const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
return send_codecs_;
}
@@ -556,8 +616,8 @@
options_ = options;
return true;
}
-VideoMediaChannel* FakeVideoEngine::CreateMediaChannel(
- MediaChannel::Role role,
+std::unique_ptr<VideoMediaSendChannelInterface>
+FakeVideoEngine::CreateSendChannel(
webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
@@ -567,54 +627,25 @@
return nullptr;
}
- FakeVideoMediaChannel* ch =
- new FakeVideoMediaChannel(role, this, options, call->network_thread());
- switch (role) {
- case MediaChannel::Role::kSend:
- send_channels_.emplace_back(ch);
- break;
- case MediaChannel::Role::kReceive:
- receive_channels_.emplace_back(ch);
- break;
- case MediaChannel::Role::kBoth:
- send_channels_.push_back(ch);
- receive_channels_.push_back(ch);
- break;
- default:
- RTC_CHECK_NOTREACHED();
- }
+ std::unique_ptr<FakeVideoMediaSendChannel> ch =
+ std::make_unique<FakeVideoMediaSendChannel>(options,
+ call->network_thread());
return ch;
}
-FakeVideoMediaChannel* FakeVideoEngine::GetSendChannel(size_t index) {
- return (send_channels_.size() > index) ? send_channels_[index] : nullptr;
-}
-FakeVideoMediaChannel* FakeVideoEngine::GetReceiveChannel(size_t index) {
- return (receive_channels_.size() > index) ? receive_channels_[index]
- : nullptr;
-}
-void FakeVideoEngine::UnregisterChannel(VideoMediaChannel* channel) {
- switch (channel->role()) {
- case MediaChannel::Role::kSend: {
- auto it = absl::c_find(send_channels_, channel);
- RTC_DCHECK(it != send_channels_.end());
- send_channels_.erase(it);
- } break;
- case MediaChannel::Role::kReceive: {
- auto it = absl::c_find(receive_channels_, channel);
- RTC_DCHECK(it != receive_channels_.end());
- receive_channels_.erase(it);
- } break;
- case MediaChannel::Role::kBoth: {
- auto it = absl::c_find(send_channels_, channel);
- RTC_DCHECK(it != send_channels_.end());
- send_channels_.erase(it);
- it = absl::c_find(receive_channels_, channel);
- RTC_DCHECK(it != receive_channels_.end());
- receive_channels_.erase(it);
- } break;
- default:
- RTC_CHECK_NOTREACHED();
+std::unique_ptr<VideoMediaReceiveChannelInterface>
+FakeVideoEngine::CreateReceiveChannel(
+ webrtc::Call* call,
+ const MediaConfig& config,
+ const VideoOptions& options,
+ const webrtc::CryptoOptions& crypto_options) {
+ if (fail_create_channel_) {
+ return nullptr;
}
+
+ std::unique_ptr<FakeVideoMediaReceiveChannel> ch =
+ std::make_unique<FakeVideoMediaReceiveChannel>(options,
+ call->network_thread());
+ return ch;
}
std::vector<VideoCodec> FakeVideoEngine::send_codecs(bool use_rtx) const {
return send_codecs_;
@@ -666,20 +697,6 @@
video_->SetSendCodecs(codecs);
video_->SetRecvCodecs(codecs);
}
-
-FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceSendChannel(size_t index) {
- return voice_->GetSendChannel(index);
-}
-FakeVideoMediaChannel* FakeMediaEngine::GetVideoSendChannel(size_t index) {
- return video_->GetSendChannel(index);
-}
-FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceReceiveChannel(size_t index) {
- return voice_->GetReceiveChannel(index);
-}
-FakeVideoMediaChannel* FakeMediaEngine::GetVideoReceiveChannel(size_t index) {
- return video_->GetReceiveChannel(index);
-}
-
void FakeMediaEngine::set_fail_create_channel(bool fail) {
voice_->fail_create_channel_ = fail;
video_->fail_create_channel_ = fail;
diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h
index caa5fab..34c91cf 100644
--- a/media/base/fake_media_engine.h
+++ b/media/base/fake_media_engine.h
@@ -18,11 +18,16 @@
#include <set>
#include <string>
#include <tuple>
+#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
+#include "absl/functional/any_invocable.h"
#include "api/call/audio_sink.h"
+#include "api/media_types.h"
#include "media/base/audio_source.h"
+#include "media/base/media_channel.h"
+#include "media/base/media_channel_impl.h"
#include "media/base/media_engine.h"
#include "media/base/rtp_utils.h"
#include "media/base/stream_params.h"
@@ -43,41 +48,22 @@
// A common helper class that handles sending and receiving RTP/RTCP packets.
template <class Base>
-class RtpHelper : public Base {
+class RtpReceiveChannelHelper : public Base, public MediaChannelUtil {
public:
- explicit RtpHelper(MediaChannel::Role role,
- webrtc::TaskQueueBase* network_thread)
- : Base(role, network_thread),
- sending_(false),
+ explicit RtpReceiveChannelHelper(webrtc::TaskQueueBase* network_thread)
+ : MediaChannelUtil(network_thread),
playout_(false),
- fail_set_send_codecs_(false),
fail_set_recv_codecs_(false),
- send_ssrc_(0),
- ready_to_send_(false),
transport_overhead_per_packet_(0),
num_network_route_changes_(0) {}
- virtual ~RtpHelper() = default;
+ virtual ~RtpReceiveChannelHelper() = default;
const std::vector<RtpExtension>& recv_extensions() {
return recv_extensions_;
}
- const std::vector<RtpExtension>& send_extensions() {
- return send_extensions_;
- }
- bool sending() const { return sending_; }
bool playout() const { return playout_; }
const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
- bool SendRtp(const void* data,
- size_t len,
- const rtc::PacketOptions& options) {
- if (!sending_) {
- return false;
- }
- rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
- kMaxRtpPacketLen);
- return Base::SendPacket(&packet, options);
- }
bool SendRtcp(const void* data, size_t len) {
rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
kMaxRtpPacketLen);
@@ -104,37 +90,18 @@
}
bool CheckNoRtp() { return rtp_packets_.empty(); }
bool CheckNoRtcp() { return rtcp_packets_.empty(); }
- void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
void set_fail_set_recv_codecs(bool fail) { fail_set_recv_codecs_ = fail; }
- virtual bool AddSendStream(const StreamParams& sp) {
- if (absl::c_linear_search(send_streams_, sp)) {
- return false;
- }
- send_streams_.push_back(sp);
- rtp_send_parameters_[sp.first_ssrc()] =
- CreateRtpParametersWithEncodings(sp);
- return true;
- }
- virtual bool RemoveSendStream(uint32_t ssrc) {
- auto parameters_iterator = rtp_send_parameters_.find(ssrc);
- if (parameters_iterator != rtp_send_parameters_.end()) {
- rtp_send_parameters_.erase(parameters_iterator);
- }
- return RemoveStreamBySsrc(&send_streams_, ssrc);
- }
- virtual void ResetUnsignaledRecvStream() {}
- virtual absl::optional<uint32_t> GetUnsignaledSsrc() const {
+ void ResetUnsignaledRecvStream() override {}
+ absl::optional<uint32_t> GetUnsignaledSsrc() const override {
return absl::nullopt;
}
void ChooseReceiverReportSsrc(const std::set<uint32_t>& choices) override {}
- void SetSsrcListChangedCallback(
- absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {}
virtual bool SetLocalSsrc(const StreamParams& sp) { return true; }
- virtual void OnDemuxerCriteriaUpdatePending() {}
- virtual void OnDemuxerCriteriaUpdateComplete() {}
+ void OnDemuxerCriteriaUpdatePending() override {}
+ void OnDemuxerCriteriaUpdateComplete() override {}
- virtual bool AddRecvStream(const StreamParams& sp) {
+ bool AddRecvStream(const StreamParams& sp) override {
if (absl::c_linear_search(receive_streams_, sp)) {
return false;
}
@@ -143,11 +110,7 @@
CreateRtpParametersWithEncodings(sp);
return true;
}
- virtual bool AddDefaultRecvStreamForTesting(const StreamParams& sp) {
- RTC_CHECK_NOTREACHED();
- return false;
- }
- virtual bool RemoveRecvStream(uint32_t ssrc) {
+ bool RemoveRecvStream(uint32_t ssrc) override {
auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
if (parameters_iterator != rtp_receive_parameters_.end()) {
rtp_receive_parameters_.erase(parameters_iterator);
@@ -155,17 +118,191 @@
return RemoveStreamBySsrc(&receive_streams_, ssrc);
}
- virtual webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const {
+ webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const override {
+ auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
+ if (parameters_iterator != rtp_receive_parameters_.end()) {
+ return parameters_iterator->second;
+ }
+ return webrtc::RtpParameters();
+ }
+ webrtc::RtpParameters GetDefaultRtpReceiveParameters() const override {
+ return webrtc::RtpParameters();
+ }
+
+ const std::vector<StreamParams>& recv_streams() const {
+ return receive_streams_;
+ }
+ bool HasRecvStream(uint32_t ssrc) const {
+ return GetStreamBySsrc(receive_streams_, ssrc) != nullptr;
+ }
+
+ const RtcpParameters& recv_rtcp_parameters() { return recv_rtcp_parameters_; }
+
+ int transport_overhead_per_packet() const {
+ return transport_overhead_per_packet_;
+ }
+
+ rtc::NetworkRoute last_network_route() const { return last_network_route_; }
+ int num_network_route_changes() const { return num_network_route_changes_; }
+ void set_num_network_route_changes(int changes) {
+ num_network_route_changes_ = changes;
+ }
+
+ void OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
+ int64_t packet_time_us) {
+ rtcp_packets_.push_back(std::string(packet->cdata<char>(), packet->size()));
+ }
+
+ void SetFrameDecryptor(uint32_t ssrc,
+ rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
+ frame_decryptor) override {}
+
+ void SetDepacketizerToDecoderFrameTransformer(
+ uint32_t ssrc,
+ rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+ override {}
+
+ void SetInterface(MediaChannelNetworkInterface* iface) override {
+ network_interface_ = iface;
+ MediaChannelUtil::SetInterface(iface);
+ }
+
+ protected:
+ void set_playout(bool playout) { playout_ = playout; }
+ bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
+ recv_extensions_ = extensions;
+ return true;
+ }
+ void set_recv_rtcp_parameters(const RtcpParameters& params) {
+ recv_rtcp_parameters_ = params;
+ }
+ void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
+ rtp_packets_.push_back(
+ std::string(packet.Buffer().cdata<char>(), packet.size()));
+ }
+ bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
+
+ private:
+ bool playout_;
+ std::vector<RtpExtension> recv_extensions_;
+ std::list<std::string> rtp_packets_;
+ std::list<std::string> rtcp_packets_;
+ std::vector<StreamParams> receive_streams_;
+ RtcpParameters recv_rtcp_parameters_;
+ std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
+ bool fail_set_recv_codecs_;
+ std::string rtcp_cname_;
+ int transport_overhead_per_packet_;
+ rtc::NetworkRoute last_network_route_;
+ int num_network_route_changes_;
+ MediaChannelNetworkInterface* network_interface_ = nullptr;
+};
+
+// A common helper class that handles sending and receiving RTP/RTCP packets.
+template <class Base>
+class RtpSendChannelHelper : public Base, public MediaChannelUtil {
+ public:
+ explicit RtpSendChannelHelper(webrtc::TaskQueueBase* network_thread)
+ : MediaChannelUtil(network_thread),
+ sending_(false),
+ fail_set_send_codecs_(false),
+ send_ssrc_(0),
+ ready_to_send_(false),
+ transport_overhead_per_packet_(0),
+ num_network_route_changes_(0) {}
+ virtual ~RtpSendChannelHelper() = default;
+ const std::vector<RtpExtension>& send_extensions() {
+ return send_extensions_;
+ }
+ bool sending() const { return sending_; }
+ const std::list<std::string>& rtp_packets() const { return rtp_packets_; }
+ const std::list<std::string>& rtcp_packets() const { return rtcp_packets_; }
+
+ bool SendPacket(const void* data,
+ size_t len,
+ const rtc::PacketOptions& options) {
+ if (!sending_) {
+ return false;
+ }
+ rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
+ kMaxRtpPacketLen);
+ return MediaChannelUtil::SendPacket(&packet, options);
+ }
+ bool SendRtcp(const void* data, size_t len) {
+ rtc::CopyOnWriteBuffer packet(reinterpret_cast<const uint8_t*>(data), len,
+ kMaxRtpPacketLen);
+ return MediaChannelUtil::SendRtcp(&packet, rtc::PacketOptions());
+ }
+
+ bool CheckRtp(const void* data, size_t len) {
+ bool success = !rtp_packets_.empty();
+ if (success) {
+ std::string packet = rtp_packets_.front();
+ rtp_packets_.pop_front();
+ success = (packet == std::string(static_cast<const char*>(data), len));
+ }
+ return success;
+ }
+ bool CheckRtcp(const void* data, size_t len) {
+ bool success = !rtcp_packets_.empty();
+ if (success) {
+ std::string packet = rtcp_packets_.front();
+ rtcp_packets_.pop_front();
+ success = (packet == std::string(static_cast<const char*>(data), len));
+ }
+ return success;
+ }
+ bool CheckNoRtp() { return rtp_packets_.empty(); }
+ bool CheckNoRtcp() { return rtcp_packets_.empty(); }
+ void set_fail_set_send_codecs(bool fail) { fail_set_send_codecs_ = fail; }
+ bool AddSendStream(const StreamParams& sp) override {
+ if (absl::c_linear_search(send_streams_, sp)) {
+ return false;
+ }
+ send_streams_.push_back(sp);
+ rtp_send_parameters_[sp.first_ssrc()] =
+ CreateRtpParametersWithEncodings(sp);
+
+ if (ssrc_list_changed_callback_) {
+ std::set<uint32_t> ssrcs_in_use;
+ for (const auto& send_stream : send_streams_) {
+ ssrcs_in_use.insert(send_stream.first_ssrc());
+ }
+ ssrc_list_changed_callback_(ssrcs_in_use);
+ }
+
+ return true;
+ }
+ bool RemoveSendStream(uint32_t ssrc) override {
+ auto parameters_iterator = rtp_send_parameters_.find(ssrc);
+ if (parameters_iterator != rtp_send_parameters_.end()) {
+ rtp_send_parameters_.erase(parameters_iterator);
+ }
+ return RemoveStreamBySsrc(&send_streams_, ssrc);
+ }
+ void SetSsrcListChangedCallback(
+ absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {
+ ssrc_list_changed_callback_ = std::move(callback);
+ }
+
+ void SetExtmapAllowMixed(bool extmap_allow_mixed) override {
+ return MediaChannelUtil::SetExtmapAllowMixed(extmap_allow_mixed);
+ }
+ bool ExtmapAllowMixed() const override {
+ return MediaChannelUtil::ExtmapAllowMixed();
+ }
+
+ webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override {
auto parameters_iterator = rtp_send_parameters_.find(ssrc);
if (parameters_iterator != rtp_send_parameters_.end()) {
return parameters_iterator->second;
}
return webrtc::RtpParameters();
}
- virtual webrtc::RTCError SetRtpSendParameters(
+ webrtc::RTCError SetRtpSendParameters(
uint32_t ssrc,
const webrtc::RtpParameters& parameters,
- webrtc::SetParametersCallback callback) {
+ webrtc::SetParametersCallback callback) override {
auto parameters_iterator = rtp_send_parameters_.find(ssrc);
if (parameters_iterator != rtp_send_parameters_.end()) {
auto result = CheckRtpParametersInvalidModificationAndValues(
@@ -185,17 +322,6 @@
callback, webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR));
}
- virtual webrtc::RtpParameters GetRtpReceiveParameters(uint32_t ssrc) const {
- auto parameters_iterator = rtp_receive_parameters_.find(ssrc);
- if (parameters_iterator != rtp_receive_parameters_.end()) {
- return parameters_iterator->second;
- }
- return webrtc::RtpParameters();
- }
- virtual webrtc::RtpParameters GetDefaultRtpReceiveParameters() const {
- return webrtc::RtpParameters();
- }
-
bool IsStreamMuted(uint32_t ssrc) const {
bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
// If |ssrc = 0| check if the first send stream is muted.
@@ -208,12 +334,6 @@
const std::vector<StreamParams>& send_streams() const {
return send_streams_;
}
- const std::vector<StreamParams>& recv_streams() const {
- return receive_streams_;
- }
- bool HasRecvStream(uint32_t ssrc) const {
- return GetStreamBySsrc(receive_streams_, ssrc) != nullptr;
- }
bool HasSendStream(uint32_t ssrc) const {
return GetStreamBySsrc(send_streams_, ssrc) != nullptr;
}
@@ -225,15 +345,7 @@
return send_streams_[0].first_ssrc();
}
- // TODO(perkj): This is to support legacy unit test that only check one
- // sending stream.
- const std::string rtcp_cname() {
- if (send_streams_.empty())
- return "";
- return send_streams_[0].cname;
- }
const RtcpParameters& send_rtcp_parameters() { return send_rtcp_parameters_; }
- const RtcpParameters& recv_rtcp_parameters() { return recv_rtcp_parameters_; }
bool ready_to_send() const { return ready_to_send_; }
@@ -261,18 +373,9 @@
rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
override {}
- void SetFrameDecryptor(uint32_t ssrc,
- rtc::scoped_refptr<webrtc::FrameDecryptorInterface>
- frame_decryptor) override {}
-
- void SetDepacketizerToDecoderFrameTransformer(
- uint32_t ssrc,
- rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
- override {}
-
void SetInterface(MediaChannelNetworkInterface* iface) override {
network_interface_ = iface;
- MediaChannel::SetInterface(iface);
+ MediaChannelUtil::SetInterface(iface);
}
bool HasNetworkInterface() const override {
return network_interface_ != nullptr;
@@ -294,17 +397,6 @@
sending_ = send;
return true;
}
- void set_playout(bool playout) { playout_ = playout; }
- bool SetRecvRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
- recv_extensions_ = extensions;
- return true;
- }
- bool SetSendExtmapAllowMixed(bool extmap_allow_mixed) {
- if (Base::ExtmapAllowMixed() != extmap_allow_mixed) {
- Base::SetExtmapAllowMixed(extmap_allow_mixed);
- }
- return true;
- }
bool SetSendRtpHeaderExtensions(const std::vector<RtpExtension>& extensions) {
send_extensions_ = extensions;
return true;
@@ -312,13 +404,6 @@
void set_send_rtcp_parameters(const RtcpParameters& params) {
send_rtcp_parameters_ = params;
}
- void set_recv_rtcp_parameters(const RtcpParameters& params) {
- recv_rtcp_parameters_ = params;
- }
- void OnPacketReceived(const webrtc::RtpPacketReceived& packet) override {
- rtp_packets_.push_back(
- std::string(packet.Buffer().cdata<char>(), packet.size()));
- }
void OnPacketSent(const rtc::SentPacket& sent_packet) override {}
void OnReadyToSend(bool ready) override { ready_to_send_ = ready; }
void OnNetworkRouteChanged(absl::string_view transport_name,
@@ -328,27 +413,20 @@
transport_overhead_per_packet_ = network_route.packet_overhead;
}
bool fail_set_send_codecs() const { return fail_set_send_codecs_; }
- bool fail_set_recv_codecs() const { return fail_set_recv_codecs_; }
private:
// TODO(bugs.webrtc.org/12783): This flag is used from more than one thread.
// As a workaround for tsan, it's currently std::atomic but that might not
// be the appropriate fix.
std::atomic<bool> sending_;
- bool playout_;
- std::vector<RtpExtension> recv_extensions_;
std::vector<RtpExtension> send_extensions_;
std::list<std::string> rtp_packets_;
std::list<std::string> rtcp_packets_;
std::vector<StreamParams> send_streams_;
- std::vector<StreamParams> receive_streams_;
RtcpParameters send_rtcp_parameters_;
- RtcpParameters recv_rtcp_parameters_;
std::set<uint32_t> muted_streams_;
std::map<uint32_t, webrtc::RtpParameters> rtp_send_parameters_;
- std::map<uint32_t, webrtc::RtpParameters> rtp_receive_parameters_;
bool fail_set_send_codecs_;
- bool fail_set_recv_codecs_;
uint32_t send_ssrc_;
std::string rtcp_cname_;
bool ready_to_send_;
@@ -356,9 +434,12 @@
rtc::NetworkRoute last_network_route_;
int num_network_route_changes_;
MediaChannelNetworkInterface* network_interface_ = nullptr;
+ absl::AnyInvocable<void(const std::set<uint32_t>&)>
+ ssrc_list_changed_callback_ = nullptr;
};
-class FakeVoiceMediaChannel : public RtpHelper<VoiceMediaChannel> {
+class FakeVoiceMediaReceiveChannel
+ : public RtpReceiveChannelHelper<VoiceMediaReceiveChannelInterface> {
public:
struct DtmfInfo {
DtmfInfo(uint32_t ssrc, int event_code, int duration);
@@ -366,36 +447,34 @@
int event_code;
int duration;
};
- FakeVoiceMediaChannel(MediaChannel::Role role,
- FakeVoiceEngine* engine,
- const AudioOptions& options,
- webrtc::TaskQueueBase* network_thread);
- ~FakeVoiceMediaChannel();
+ FakeVoiceMediaReceiveChannel(const AudioOptions& options,
+ webrtc::TaskQueueBase* network_thread);
+ virtual ~FakeVoiceMediaReceiveChannel();
+
+ // Test methods
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;
+ bool HasSource(uint32_t ssrc) const;
+
+ // Overrides
+ VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
+ return nullptr;
+ }
+ VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
+ return this;
+ }
+ cricket::MediaType media_type() const override {
+ return cricket::MEDIA_TYPE_AUDIO;
+ }
bool SetRecvParameters(const AudioRecvParameters& params) override;
-
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;
bool AddRecvStream(const StreamParams& sp) override;
bool RemoveRecvStream(uint32_t ssrc) override;
- bool CanInsertDtmf() override;
- bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override;
-
bool SetOutputVolume(uint32_t ssrc, double volume) override;
bool SetDefaultOutputVolume(double volume) override;
@@ -405,9 +484,8 @@
absl::optional<int> GetBaseMinimumPlayoutDelayMs(
uint32_t ssrc) const override;
- bool GetSendStats(VoiceMediaSendInfo* info) override;
- bool GetReceiveStats(VoiceMediaReceiveInfo* info,
- bool get_and_clear_legacy_stats) override;
+ bool GetStats(VoiceMediaReceiveInfo* info,
+ bool get_and_clear_legacy_stats) override;
void SetRawAudioSink(
uint32_t ssrc,
@@ -416,14 +494,8 @@
std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
- bool SenderNackEnabled() const override { return false; }
- bool SenderNonSenderRttEnabled() const override { return false; }
- void SetReceiveNackEnabled(bool enabled) {}
- void SetReceiveNonSenderRttEnabled(bool enabled) {}
- bool SendCodecHasNack() const override { return false; }
- void SetSendCodecChangedCallback(
- absl::AnyInvocable<void()> callback) override {}
- absl::optional<Codec> GetSendCodec() const override;
+ void SetReceiveNackEnabled(bool enabled) override {}
+ void SetReceiveNonSenderRttEnabled(bool enabled) override {}
private:
class VoiceChannelAudioSink : public AudioSource::Sink {
@@ -445,14 +517,10 @@
};
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_;
- std::vector<AudioCodec> send_codecs_;
std::map<uint32_t, double> output_scalings_;
std::map<uint32_t, int> output_delays_;
std::vector<DtmfInfo> dtmf_info_queue_;
@@ -462,56 +530,134 @@
int max_bps_;
};
+class FakeVoiceMediaSendChannel
+ : public RtpSendChannelHelper<VoiceMediaSendChannelInterface> {
+ public:
+ struct DtmfInfo {
+ DtmfInfo(uint32_t ssrc, int event_code, int duration);
+ uint32_t ssrc;
+ int event_code;
+ int duration;
+ };
+ FakeVoiceMediaSendChannel(const AudioOptions& options,
+ webrtc::TaskQueueBase* network_thread);
+ ~FakeVoiceMediaSendChannel() override;
+
+ const std::vector<AudioCodec>& send_codecs() const;
+ const std::vector<DtmfInfo>& dtmf_info_queue() const;
+ const AudioOptions& options() const;
+ int max_bps() const;
+ bool HasSource(uint32_t ssrc) const;
+ bool GetOutputVolume(uint32_t ssrc, double* volume);
+
+ // Overrides
+ VideoMediaSendChannelInterface* AsVideoSendChannel() override {
+ return nullptr;
+ }
+ VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; }
+ cricket::MediaType media_type() const override {
+ return cricket::MEDIA_TYPE_AUDIO;
+ }
+
+ bool SetSendParameters(const AudioSendParameters& params) override;
+ void SetSend(bool send) override;
+ bool SetAudioSend(uint32_t ssrc,
+ bool enable,
+ const AudioOptions* options,
+ AudioSource* source) override;
+
+ bool CanInsertDtmf() override;
+ bool InsertDtmf(uint32_t ssrc, int event_code, int duration) override;
+
+ bool SenderNackEnabled() const override { return false; }
+ bool SenderNonSenderRttEnabled() const override { return false; }
+ void SetReceiveNackEnabled(bool enabled) {}
+ void SetReceiveNonSenderRttEnabled(bool enabled) {}
+ bool SendCodecHasNack() const override { return false; }
+ void SetSendCodecChangedCallback(
+ absl::AnyInvocable<void()> callback) override {}
+ absl::optional<Codec> GetSendCodec() const override;
+
+ bool GetStats(VoiceMediaSendInfo* stats) override;
+
+ private:
+ class VoiceChannelAudioSink : public AudioSource::Sink {
+ public:
+ 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,
+ absl::optional<int64_t> absolute_capture_timestamp_ms) override;
+ void OnClose() override;
+ int NumPreferredChannels() const override { return -1; }
+ AudioSource* source() const;
+
+ private:
+ AudioSource* source_;
+ };
+
+ bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
+ bool SetMaxSendBandwidth(int bps);
+ bool SetOptions(const AudioOptions& options);
+ bool SetLocalSource(uint32_t ssrc, AudioSource* source);
+
+ std::vector<AudioCodec> send_codecs_;
+ std::map<uint32_t, double> output_scalings_;
+ std::map<uint32_t, int> output_delays_;
+ std::vector<DtmfInfo> dtmf_info_queue_;
+ AudioOptions options_;
+ std::map<uint32_t, std::unique_ptr<VoiceChannelAudioSink>> local_sinks_;
+ int max_bps_;
+};
+
// A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
-bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
+bool CompareDtmfInfo(const FakeVoiceMediaSendChannel::DtmfInfo& info,
uint32_t ssrc,
int event_code,
int duration);
-class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
+class FakeVideoMediaReceiveChannel
+ : public RtpReceiveChannelHelper<VideoMediaReceiveChannelInterface> {
public:
- FakeVideoMediaChannel(MediaChannel::Role role,
- FakeVideoEngine* engine,
- const VideoOptions& options,
- webrtc::TaskQueueBase* network_thread);
+ FakeVideoMediaReceiveChannel(const VideoOptions& options,
+ webrtc::TaskQueueBase* network_thread);
- ~FakeVideoMediaChannel();
+ virtual ~FakeVideoMediaReceiveChannel();
+
+ VideoMediaReceiveChannelInterface* AsVideoReceiveChannel() override {
+ return this;
+ }
+ VoiceMediaReceiveChannelInterface* AsVoiceReceiveChannel() override {
+ return nullptr;
+ }
+ cricket::MediaType media_type() const override {
+ return cricket::MEDIA_TYPE_VIDEO;
+ }
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;
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;
- absl::optional<Codec> GetSendCodec() const override;
bool SetSink(uint32_t ssrc,
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
void SetDefaultSink(
rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override;
bool HasSink(uint32_t ssrc) const;
- bool SetSend(bool send) override;
void SetReceive(bool receive) override {}
- bool SetVideoSend(
- uint32_t ssrc,
- const VideoOptions* options,
- rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override;
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 GetSendStats(VideoMediaSendInfo* info) override;
- bool GetReceiveStats(VideoMediaReceiveInfo* info) override;
-
std::vector<webrtc::RtpSource> GetSources(uint32_t ssrc) const override;
bool SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, int delay_ms) override;
@@ -524,6 +670,67 @@
override;
void ClearRecordableEncodedFrameCallback(uint32_t ssrc) override;
void RequestRecvKeyFrame(uint32_t ssrc) override;
+ void SetReceiverFeedbackParameters(bool lntf_enabled,
+ bool nack_enabled,
+ webrtc::RtcpMode rtcp_mode,
+ absl::optional<int> rtx_time) override {}
+ bool GetStats(VideoMediaReceiveInfo* info) override;
+
+ bool AddDefaultRecvStreamForTesting(const StreamParams& sp) override {
+ RTC_CHECK_NOTREACHED();
+ return false;
+ }
+
+ private:
+ bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
+ bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
+ bool SetOptions(const VideoOptions& options);
+ bool SetMaxSendBandwidth(int bps);
+
+ std::vector<VideoCodec> recv_codecs_;
+ std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
+ std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
+ std::map<uint32_t, int> output_delays_;
+ VideoOptions options_;
+ int max_bps_;
+};
+
+class FakeVideoMediaSendChannel
+ : public RtpSendChannelHelper<VideoMediaSendChannelInterface> {
+ public:
+ FakeVideoMediaSendChannel(const VideoOptions& options,
+ webrtc::TaskQueueBase* network_thread);
+
+ virtual ~FakeVideoMediaSendChannel();
+
+ VideoMediaSendChannelInterface* AsVideoSendChannel() override { return this; }
+ VoiceMediaSendChannelInterface* AsVoiceSendChannel() override {
+ return nullptr;
+ }
+ cricket::MediaType media_type() const override {
+ return cricket::MEDIA_TYPE_VIDEO;
+ }
+
+ const std::vector<VideoCodec>& send_codecs() const;
+ const std::vector<VideoCodec>& codecs() const;
+ const VideoOptions& options() const;
+ const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
+ sinks() const;
+ int max_bps() const;
+ bool SetSendParameters(const VideoSendParameters& params) override;
+
+ absl::optional<Codec> GetSendCodec() const override;
+
+ bool SetSend(bool send) override;
+ bool SetVideoSend(
+ uint32_t ssrc,
+ const VideoOptions* options,
+ rtc::VideoSourceInterface<webrtc::VideoFrame>* source) override;
+
+ bool HasSource(uint32_t ssrc) const;
+
+ void FillBitrateInfo(BandwidthEstimationInfo* bwe_info) override;
+
void GenerateSendKeyFrame(uint32_t ssrc,
const std::vector<std::string>& rids) override;
webrtc::RtcpMode SendCodecRtcpMode() const override {
@@ -534,28 +741,21 @@
void SetSsrcListChangedCallback(
absl::AnyInvocable<void(const std::set<uint32_t>&)> callback) override {}
+ void SetVideoCodecSwitchingEnabled(bool enabled) override {}
bool SendCodecHasLntf() const override { return false; }
bool SendCodecHasNack() const override { return false; }
absl::optional<int> SendCodecRtxTime() const override {
return absl::nullopt;
}
- void SetReceiverFeedbackParameters(bool lntf_enabled,
- bool nack_enabled,
- webrtc::RtcpMode rtcp_mode,
- absl::optional<int> rtx_time) override {}
+ bool GetStats(VideoMediaSendInfo* info) override;
private:
- 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_;
std::vector<VideoCodec> send_codecs_;
- std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
- std::map<uint32_t, int> output_delays_;
VideoOptions options_;
int max_bps_;
};
@@ -566,16 +766,41 @@
void Init() override;
rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const override;
+ std::unique_ptr<VoiceMediaSendChannelInterface> CreateSendChannel(
+ webrtc::Call* call,
+ const MediaConfig& config,
+ const AudioOptions& options,
+ const webrtc::CryptoOptions& crypto_options,
+ webrtc::AudioCodecPairId codec_pair_id) override;
+ std::unique_ptr<VoiceMediaReceiveChannelInterface> CreateReceiveChannel(
+ webrtc::Call* call,
+ const MediaConfig& config,
+ const AudioOptions& options,
+ const webrtc::CryptoOptions& crypto_options,
+ webrtc::AudioCodecPairId codec_pair_id) override;
VoiceMediaChannel* CreateMediaChannel(
MediaChannel::Role role,
webrtc::Call* call,
const MediaConfig& config,
const AudioOptions& options,
const webrtc::CryptoOptions& crypto_options,
- webrtc::AudioCodecPairId codec_pair_id) override;
- FakeVoiceMediaChannel* GetSendChannel(size_t index);
- FakeVoiceMediaChannel* GetReceiveChannel(size_t index);
- void UnregisterChannel(VoiceMediaChannel* channel);
+ webrtc::AudioCodecPairId codec_pair_id) override {
+ RTC_DCHECK_RUN_ON(call->worker_thread());
+ std::unique_ptr<VoiceMediaSendChannelInterface> send_channel;
+ std::unique_ptr<VoiceMediaReceiveChannelInterface> receive_channel;
+ if (role == MediaChannel::Role::kSend ||
+ role == MediaChannel::Role::kBoth) {
+ send_channel = CreateSendChannel(call, config, options, crypto_options,
+ codec_pair_id);
+ }
+ if (role == MediaChannel::Role::kReceive ||
+ role == MediaChannel::Role::kBoth) {
+ receive_channel = CreateReceiveChannel(call, config, options,
+ crypto_options, codec_pair_id);
+ }
+ return new VoiceMediaShimChannel(std::move(send_channel),
+ std::move(receive_channel));
+ }
// TODO(ossu): For proper testing, These should either individually settable
// or the voice engine should reference mockable factories.
@@ -595,8 +820,6 @@
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
private:
- std::vector<FakeVoiceMediaChannel*> send_channels_;
- std::vector<FakeVoiceMediaChannel*> receive_channels_;
std::vector<AudioCodec> recv_codecs_;
std::vector<AudioCodec> send_codecs_;
bool fail_create_channel_;
@@ -609,6 +832,18 @@
public:
FakeVideoEngine();
bool SetOptions(const VideoOptions& options);
+ std::unique_ptr<VideoMediaSendChannelInterface> CreateSendChannel(
+ webrtc::Call* call,
+ const MediaConfig& config,
+ const VideoOptions& options,
+ const webrtc::CryptoOptions& crypto_options,
+ webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
+ override;
+ std::unique_ptr<VideoMediaReceiveChannelInterface> CreateReceiveChannel(
+ webrtc::Call* call,
+ const MediaConfig& config,
+ const VideoOptions& options,
+ const webrtc::CryptoOptions& crypto_options) override;
VideoMediaChannel* CreateMediaChannel(
MediaChannel::Role role,
webrtc::Call* call,
@@ -616,10 +851,26 @@
const VideoOptions& options,
const webrtc::CryptoOptions& crypto_options,
webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
- override;
- FakeVideoMediaChannel* GetSendChannel(size_t index);
- FakeVideoMediaChannel* GetReceiveChannel(size_t index);
- void UnregisterChannel(VideoMediaChannel* channel);
+ override {
+ RTC_LOG(LS_INFO) << "CreateMediaChannel. Options: " << options.ToString();
+ std::unique_ptr<VideoMediaSendChannelInterface> send_channel;
+ std::unique_ptr<VideoMediaReceiveChannelInterface> receive_channel;
+ if (role == MediaChannel::Role::kSend ||
+ role == MediaChannel::Role::kBoth) {
+ send_channel = CreateSendChannel(call, config, options, crypto_options,
+ video_bitrate_allocator_factory);
+ }
+ if (role == MediaChannel::Role::kReceive ||
+ role == MediaChannel::Role::kBoth) {
+ receive_channel =
+ CreateReceiveChannel(call, config, options, crypto_options);
+ }
+ return new VideoMediaShimChannel(std::move(send_channel),
+ std::move(receive_channel));
+ }
+ FakeVideoMediaSendChannel* GetSendChannel(size_t index);
+ FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index);
+
std::vector<VideoCodec> send_codecs() const override {
return send_codecs(true);
}
@@ -637,8 +888,6 @@
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
private:
- std::vector<FakeVideoMediaChannel*> send_channels_;
- std::vector<FakeVideoMediaChannel*> receive_channels_;
std::vector<VideoCodec> send_codecs_;
std::vector<VideoCodec> recv_codecs_;
bool capture_;
@@ -660,13 +909,11 @@
void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs);
void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
- FakeVoiceMediaChannel* GetVoiceSendChannel(size_t index);
- FakeVideoMediaChannel* GetVideoSendChannel(size_t index);
- FakeVoiceMediaChannel* GetVoiceReceiveChannel(size_t index);
- FakeVideoMediaChannel* GetVideoReceiveChannel(size_t index);
-
void set_fail_create_channel(bool fail);
+ FakeVoiceEngine* fake_voice_engine() { return voice_; }
+ FakeVideoEngine* fake_video_engine() { return video_; }
+
private:
FakeVoiceEngine* const voice_;
FakeVideoEngine* const video_;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 2867629..0d7f0b0 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -49,7 +49,8 @@
#include "test/scoped_key_value_config.h"
using cricket::DtlsTransportInternal;
-using cricket::FakeVoiceMediaChannel;
+using cricket::FakeVoiceMediaReceiveChannel;
+using cricket::FakeVoiceMediaSendChannel;
using cricket::RidDescription;
using cricket::RidDirection;
using cricket::StreamParams;
@@ -77,9 +78,10 @@
} // namespace
template <class ChannelT,
- class MediaChannelT,
class MediaSendChannelT,
class MediaReceiveChannelT,
+ class MediaSendChannelInterfaceT,
+ class MediaReceiveChannelInterfaceT,
class ContentT,
class CodecT,
class MediaInfoT,
@@ -87,9 +89,10 @@
class Traits {
public:
typedef ChannelT Channel;
- typedef MediaChannelT MediaChannel;
typedef MediaSendChannelT MediaSendChannel;
typedef MediaReceiveChannelT MediaReceiveChannel;
+ typedef MediaSendChannelInterfaceT MediaSendChannelInterface;
+ typedef MediaReceiveChannelInterfaceT MediaReceiveChannelInterface;
typedef ContentT Content;
typedef CodecT Codec;
typedef MediaInfoT MediaInfo;
@@ -97,7 +100,8 @@
};
class VoiceTraits : public Traits<cricket::VoiceChannel,
- cricket::FakeVoiceMediaChannel,
+ cricket::FakeVoiceMediaSendChannel,
+ cricket::FakeVoiceMediaReceiveChannel,
cricket::VoiceMediaSendChannelInterface,
cricket::VoiceMediaReceiveChannelInterface,
cricket::AudioContentDescription,
@@ -106,7 +110,8 @@
cricket::AudioOptions> {};
class VideoTraits : public Traits<cricket::VideoChannel,
- cricket::FakeVideoMediaChannel,
+ cricket::FakeVideoMediaSendChannel,
+ cricket::FakeVideoMediaReceiveChannel,
cricket::VideoMediaSendChannelInterface,
cricket::VideoMediaReceiveChannelInterface,
cricket::VideoContentDescription,
@@ -154,24 +159,20 @@
}
void CreateChannels(int flags1, int flags2) {
- CreateChannels(std::make_unique<typename T::MediaChannel>(
- cricket::MediaChannel::Role::kSend, nullptr,
+ CreateChannels(std::make_unique<typename T::MediaSendChannel>(
typename T::Options(), network_thread_),
- std::make_unique<typename T::MediaChannel>(
- cricket::MediaChannel::Role::kReceive, nullptr,
+ std::make_unique<typename T::MediaReceiveChannel>(
typename T::Options(), network_thread_),
- std::make_unique<typename T::MediaChannel>(
- cricket::MediaChannel::Role::kSend, nullptr,
+ std::make_unique<typename T::MediaSendChannel>(
typename T::Options(), network_thread_),
- std::make_unique<typename T::MediaChannel>(
- cricket::MediaChannel::Role::kReceive, nullptr,
+ std::make_unique<typename T::MediaReceiveChannel>(
typename T::Options(), network_thread_),
flags1, flags2);
}
- void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1s,
- std::unique_ptr<typename T::MediaChannel> ch1r,
- std::unique_ptr<typename T::MediaChannel> ch2s,
- std::unique_ptr<typename T::MediaChannel> ch2r,
+ void CreateChannels(std::unique_ptr<typename T::MediaSendChannel> ch1s,
+ std::unique_ptr<typename T::MediaReceiveChannel> ch1r,
+ std::unique_ptr<typename T::MediaSendChannel> ch2s,
+ std::unique_ptr<typename T::MediaReceiveChannel> ch2r,
int flags1,
int flags2) {
RTC_DCHECK(!channel1_);
@@ -275,8 +276,8 @@
std::unique_ptr<typename T::Channel> CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
- std::unique_ptr<typename T::MediaChannel> ch_send,
- std::unique_ptr<typename T::MediaChannel> ch_receive,
+ std::unique_ptr<typename T::MediaSendChannel> ch_send,
+ std::unique_ptr<typename T::MediaReceiveChannel> ch_receive,
webrtc::RtpTransportInternal* rtp_transport,
int flags);
@@ -439,11 +440,11 @@
return result;
}
- void SendRtp(typename T::MediaChannel* media_channel, rtc::Buffer data) {
+ void SendRtp(typename T::MediaSendChannel* media_channel, rtc::Buffer data) {
network_thread_->PostTask(webrtc::SafeTask(
network_thread_safety_, [media_channel, data = std::move(data)]() {
- media_channel->SendRtp(data.data(), data.size(),
- rtc::PacketOptions());
+ media_channel->SendPacket(data.data(), data.size(),
+ rtc::PacketOptions());
}));
}
@@ -586,7 +587,7 @@
if (verify_playout_) {
EXPECT_FALSE(media_receive_channel1_impl()->playout());
}
- EXPECT_TRUE(media_send_channel1_impl()->codecs().empty());
+ EXPECT_TRUE(media_send_channel1_impl()->send_codecs().empty());
EXPECT_TRUE(media_receive_channel1_impl()->recv_streams().empty());
EXPECT_TRUE(media_send_channel1_impl()->rtp_packets().empty());
// Basic sanity test for send and receive channel objects
@@ -606,11 +607,11 @@
CreateContent(0, kPcmuCodec, kH264Codec, &content);
std::string err;
EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err));
- EXPECT_EQ(0U, media_send_channel1_impl()->codecs().size());
+ EXPECT_EQ(0U, media_send_channel1_impl()->send_codecs().size());
EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
- ASSERT_EQ(1U, media_send_channel1_impl()->codecs().size());
+ ASSERT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
EXPECT_TRUE(CodecMatches(content.codecs()[0],
- media_send_channel1_impl()->codecs()[0]));
+ media_send_channel1_impl()->send_codecs()[0]));
}
// Test that SetLocalContent and SetRemoteContent properly configure
@@ -654,11 +655,11 @@
std::string err;
EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err));
CreateContent(0, kPcmuCodec, kH264Codec, &content);
- EXPECT_EQ(0U, media_send_channel1_impl()->codecs().size());
+ EXPECT_EQ(0U, media_send_channel1_impl()->send_codecs().size());
EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err));
- ASSERT_EQ(1U, media_send_channel1_impl()->codecs().size());
+ ASSERT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
EXPECT_TRUE(CodecMatches(content.codecs()[0],
- media_send_channel1_impl()->codecs()[0]));
+ media_send_channel1_impl()->send_codecs()[0]));
}
// Test that SetLocalContent and SetRemoteContent properly set RTCP
@@ -911,7 +912,7 @@
CreateChannels(DTLS, DTLS);
SendInitiate();
- typename T::MediaChannel* media_send_channel1_impl =
+ typename T::MediaSendChannel* media_send_channel1_impl =
this->media_send_channel1_impl();
ASSERT_TRUE(media_send_channel1_impl);
@@ -973,12 +974,12 @@
EXPECT_TRUE(SendAccept());
EXPECT_FALSE(IsSrtpActive(channel1_));
EXPECT_TRUE(media_send_channel1_impl()->sending());
- EXPECT_EQ(1U, media_send_channel1_impl()->codecs().size());
+ EXPECT_EQ(1U, media_send_channel1_impl()->send_codecs().size());
if (verify_playout_) {
EXPECT_TRUE(media_receive_channel2_impl()->playout());
}
EXPECT_TRUE(media_send_channel2_impl()->sending());
- EXPECT_EQ(1U, media_send_channel2_impl()->codecs().size());
+ EXPECT_EQ(1U, media_send_channel2_impl()->send_codecs().size());
}
// Send voice RTP data to the other side and ensure it gets there.
@@ -1457,46 +1458,47 @@
}
// Accessors that return the standard VideoMedia{Send|Receive}ChannelInterface
- typename T::MediaSendChannel* media_send_channel1() {
+ typename T::MediaSendChannelInterface* media_send_channel1() {
return channel1_->media_send_channel();
}
- typename T::MediaSendChannel* media_send_channel2() {
+ typename T::MediaSendChannelInterface* media_send_channel2() {
return channel2_->media_send_channel();
}
- typename T::MediaReceiveChannel* media_receive_channel1() {
+ typename T::MediaReceiveChannelInterface* media_receive_channel1() {
return channel1_->media_receive_channel();
}
- typename T::MediaReceiveChannel* media_receive_channel2() {
+ typename T::MediaReceiveChannelInterface* media_receive_channel2() {
return channel2_->media_receive_channel();
}
- // Accessors that return the FakeMedia<type>Channel object.
+ // Accessors that return the FakeMedia<type>SendChannel object.
// Note that these depend on getting the object back that was
// passed to the channel constructor.
- // T::MediaChannel is either FakeVoiceMediaChannel or FakeVideoMediaChannel.
- typename T::MediaChannel* media_send_channel1_impl() {
+ // T::MediaSendChannel is either FakeVoiceMediaSendChannel or
+ // FakeVideoMediaSendChannel.
+ typename T::MediaSendChannel* media_send_channel1_impl() {
RTC_DCHECK(channel1_);
- return static_cast<typename T::MediaChannel*>(
+ return static_cast<typename T::MediaSendChannel*>(
channel1_->media_send_channel());
}
- typename T::MediaChannel* media_send_channel2_impl() {
+ typename T::MediaSendChannel* media_send_channel2_impl() {
RTC_DCHECK(channel2_);
RTC_DCHECK(channel2_->media_send_channel());
- return static_cast<typename T::MediaChannel*>(
+ return static_cast<typename T::MediaSendChannel*>(
channel2_->media_send_channel());
}
- typename T::MediaChannel* media_receive_channel1_impl() {
+ typename T::MediaReceiveChannel* media_receive_channel1_impl() {
RTC_DCHECK(channel1_);
RTC_DCHECK(channel1_->media_receive_channel());
- return static_cast<typename T::MediaChannel*>(
+ return static_cast<typename T::MediaReceiveChannel*>(
channel1_->media_receive_channel());
}
- typename T::MediaChannel* media_receive_channel2_impl() {
+ typename T::MediaReceiveChannel* media_receive_channel2_impl() {
RTC_DCHECK(channel2_);
RTC_DCHECK(channel2_->media_receive_channel());
- return static_cast<typename T::MediaChannel*>(
+ return static_cast<typename T::MediaReceiveChannel*>(
channel2_->media_receive_channel());
}
@@ -1538,8 +1540,8 @@
std::unique_ptr<cricket::VoiceChannel> ChannelTest<VoiceTraits>::CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
- std::unique_ptr<cricket::FakeVoiceMediaChannel> send_ch,
- std::unique_ptr<cricket::FakeVoiceMediaChannel> receive_ch,
+ std::unique_ptr<cricket::FakeVoiceMediaSendChannel> send_ch,
+ std::unique_ptr<cricket::FakeVoiceMediaReceiveChannel> receive_ch,
webrtc::RtpTransportInternal* rtp_transport,
int flags) {
rtc::Thread* signaling_thread = rtc::Thread::Current();
@@ -1625,8 +1627,8 @@
std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel(
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
- std::unique_ptr<cricket::FakeVideoMediaChannel> send_ch,
- std::unique_ptr<cricket::FakeVideoMediaChannel> receive_ch,
+ std::unique_ptr<cricket::FakeVideoMediaSendChannel> send_ch,
+ std::unique_ptr<cricket::FakeVideoMediaReceiveChannel> receive_ch,
webrtc::RtpTransportInternal* rtp_transport,
int flags) {
rtc::Thread* signaling_thread = rtc::Thread::Current();
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index 72bd9bd..87e018b 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -43,6 +43,7 @@
#include "api/task_queue/task_queue_factory.h"
#include "media/base/codec.h"
#include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
#include "media/base/media_constants.h"
#include "media/base/media_engine.h"
#include "media/base/stream_params.h"
@@ -50,9 +51,11 @@
#include "p2p/base/p2p_constants.h"
#include "p2p/base/port_allocator.h"
#include "p2p/base/transport_info.h"
+#include "pc/channel_interface.h"
#include "pc/media_session.h"
#include "pc/peer_connection_wrapper.h"
#include "pc/rtp_media_utils.h"
+#include "pc/rtp_transceiver.h"
#include "pc/session_description.h"
#include "pc/test/mock_peer_connection_observers.h"
#include "rtc_base/checks.h"
@@ -78,6 +81,47 @@
using ::testing::NotNull;
using ::testing::Values;
+cricket::MediaSendChannelInterface* SendChannelInternal(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
+ webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+ transceiver.get());
+ auto transceiver_internal =
+ static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
+ return transceiver_internal->channel()->media_send_channel();
+}
+
+cricket::MediaReceiveChannelInterface* ReceiveChannelInternal(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
+ webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+ transceiver.get());
+ auto transceiver_internal =
+ static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
+ return transceiver_internal->channel()->media_receive_channel();
+}
+
+cricket::FakeVideoMediaSendChannel* VideoMediaSendChannel(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ return static_cast<cricket::FakeVideoMediaSendChannel*>(
+ SendChannelInternal(transceiver));
+}
+cricket::FakeVideoMediaReceiveChannel* VideoMediaReceiveChannel(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
+ ReceiveChannelInternal(transceiver));
+}
+cricket::FakeVoiceMediaSendChannel* VoiceMediaSendChannel(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ return static_cast<cricket::FakeVoiceMediaSendChannel*>(
+ SendChannelInternal(transceiver));
+}
+cricket::FakeVoiceMediaReceiveChannel* VoiceMediaReceiveChannel(
+ rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+ return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
+ ReceiveChannelInternal(transceiver));
+}
+
class PeerConnectionWrapperForMediaTest : public PeerConnectionWrapper {
public:
using PeerConnectionWrapper::PeerConnectionWrapper;
@@ -272,7 +316,8 @@
// Test that exchanging an offer and answer with each side having an audio and
// video stream creates the appropriate send/recv streams in the underlying
// media engine on both sides.
-TEST_P(PeerConnectionMediaTest, AudioVideoOfferAnswerCreateSendRecvStreams) {
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
+ AudioVideoOfferAnswerCreateSendRecvStreams) {
const std::string kCallerAudioId = "caller_a";
const std::string kCallerVideoId = "caller_v";
const std::string kCalleeAudioId = "callee_a";
@@ -290,33 +335,37 @@
ASSERT_TRUE(
caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
- auto* caller_voice_send = caller->media_engine()->GetVoiceSendChannel(0);
+ auto* caller_voice_send =
+ VoiceMediaSendChannel(caller->pc()->GetTransceivers()[0]);
auto* caller_voice_receive =
- caller->media_engine()->GetVoiceReceiveChannel(0);
+ VoiceMediaReceiveChannel(caller->pc()->GetTransceivers()[0]);
EXPECT_THAT(GetIds(caller_voice_receive->recv_streams()),
ElementsAre(kCalleeAudioId));
EXPECT_THAT(GetIds(caller_voice_send->send_streams()),
ElementsAre(kCallerAudioId));
- auto* caller_video_send = caller->media_engine()->GetVideoSendChannel(0);
+ auto* caller_video_send =
+ VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
auto* caller_video_receive =
- caller->media_engine()->GetVideoReceiveChannel(0);
+ VideoMediaReceiveChannel(caller->pc()->GetTransceivers()[1]);
EXPECT_THAT(GetIds(caller_video_receive->recv_streams()),
ElementsAre(kCalleeVideoId));
EXPECT_THAT(GetIds(caller_video_send->send_streams()),
ElementsAre(kCallerVideoId));
- auto* callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
+ auto* callee_voice_send =
+ VoiceMediaSendChannel(callee->pc()->GetTransceivers()[0]);
auto* callee_voice_receive =
- callee->media_engine()->GetVoiceReceiveChannel(0);
+ VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[0]);
EXPECT_THAT(GetIds(callee_voice_receive->recv_streams()),
ElementsAre(kCallerAudioId));
EXPECT_THAT(GetIds(callee_voice_send->send_streams()),
ElementsAre(kCalleeAudioId));
- auto* callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
+ auto* callee_video_send =
+ VideoMediaSendChannel(callee->pc()->GetTransceivers()[1]);
auto* callee_video_receive =
- callee->media_engine()->GetVideoReceiveChannel(0);
+ VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[1]);
EXPECT_THAT(GetIds(callee_video_receive->recv_streams()),
ElementsAre(kCallerVideoId));
EXPECT_THAT(GetIds(callee_video_send->send_streams()),
@@ -342,10 +391,7 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
- ASSERT_FALSE(callee->media_engine()->GetVoiceSendChannel(0));
- ASSERT_FALSE(callee->media_engine()->GetVideoSendChannel(0));
- ASSERT_FALSE(callee->media_engine()->GetVoiceReceiveChannel(0));
- ASSERT_FALSE(callee->media_engine()->GetVideoReceiveChannel(0));
+ ASSERT_TRUE(callee->pc()->GetTransceivers().empty());
}
// Test that removing streams from a subsequent offer causes the receive streams
@@ -365,14 +411,8 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
- auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
- auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
- auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
- auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
- EXPECT_EQ(1u, callee_voice_send->send_streams().size());
- EXPECT_EQ(0u, callee_voice_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_video_send->send_streams().size());
- EXPECT_EQ(0u, callee_video_receive->recv_streams().size());
+ EXPECT_TRUE(callee->pc()->GetReceivers().empty());
+ EXPECT_EQ(2u, callee->pc()->GetSenders().size());
}
// Test enabling of simulcast with Plan B semantics.
@@ -444,8 +484,7 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
- EXPECT_FALSE(callee->media_engine()->GetVoiceReceiveChannel(0));
- EXPECT_FALSE(callee->media_engine()->GetVideoReceiveChannel(0));
+ EXPECT_TRUE(callee->pc()->GetTransceivers().empty());
}
// Test that removing streams from a subsequent answer causes the send streams
@@ -465,14 +504,8 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
- auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
- auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
- auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
- auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
- EXPECT_EQ(0u, callee_voice_send->send_streams().size());
- EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
- EXPECT_EQ(0u, callee_video_send->send_streams().size());
- EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
+ EXPECT_TRUE(callee->pc()->GetSenders().empty());
+ EXPECT_EQ(2u, callee->pc()->GetReceivers().size());
}
// Test that a new stream in a subsequent offer causes a new receive stream to
@@ -489,11 +522,12 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
- auto a1 = callee->media_engine()->GetVoiceReceiveChannel(0);
- auto a2 = callee->media_engine()->GetVoiceReceiveChannel(1);
- auto v1 = callee->media_engine()->GetVideoReceiveChannel(0);
- auto v2 = callee->media_engine()->GetVideoReceiveChannel(1);
if (IsUnifiedPlan()) {
+ auto a1 = VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[0]);
+ auto a2 = VoiceMediaReceiveChannel(callee->pc()->GetTransceivers()[2]);
+ auto v1 = VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[1]);
+ auto v2 = VideoMediaReceiveChannel(callee->pc()->GetTransceivers()[3]);
+
ASSERT_TRUE(a1);
EXPECT_EQ(1u, a1->recv_streams().size());
ASSERT_TRUE(a2);
@@ -503,12 +537,7 @@
ASSERT_TRUE(v2);
EXPECT_EQ(1u, v2->recv_streams().size());
} else {
- ASSERT_TRUE(a1);
- EXPECT_EQ(2u, a1->recv_streams().size());
- ASSERT_FALSE(a2);
- ASSERT_TRUE(v1);
- EXPECT_EQ(2u, v1->recv_streams().size());
- ASSERT_FALSE(v2);
+ EXPECT_EQ(4u, callee->pc()->GetReceivers().size());
}
}
@@ -535,17 +564,18 @@
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get(), offer_options,
answer_options));
- auto callee_voice = callee->media_engine()->GetVoiceSendChannel(0);
- ASSERT_TRUE(callee_voice);
- auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
- ASSERT_TRUE(callee_video);
-
if (IsUnifiedPlan()) {
+ auto callee_voice =
+ VoiceMediaSendChannel(callee->pc()->GetTransceivers()[0]);
+ ASSERT_TRUE(callee_voice);
+ auto callee_video =
+ VideoMediaSendChannel(callee->pc()->GetTransceivers()[1]);
+ ASSERT_TRUE(callee_video);
+
EXPECT_EQ(1u, callee_voice->send_streams().size());
EXPECT_EQ(1u, callee_video->send_streams().size());
} else {
- EXPECT_EQ(2u, callee_voice->send_streams().size());
- EXPECT_EQ(2u, callee_video->send_streams().size());
+ EXPECT_EQ(4u, callee->pc()->GetSenders().size());
}
}
@@ -1088,158 +1118,18 @@
ChangeMediaTypeAudioToVideo,
kMLinesOutOfOrder))));
-// Test that the correct media engine send/recv streams are created when doing
-// a series of offer/answers where audio/video are both sent, then audio is
-// rejected, then both audio/video sent again.
-TEST_P(PeerConnectionMediaTest, TestAVOfferWithAudioOnlyAnswer) {
- if (IsUnifiedPlan()) {
- // offer_to_receive_ is not implemented when creating answers with Unified
- // Plan semantics specified.
- return;
- }
-
- RTCOfferAnswerOptions options_reject_video;
- options_reject_video.offer_to_receive_audio =
- RTCOfferAnswerOptions::kOfferToReceiveMediaTrue;
- options_reject_video.offer_to_receive_video = 0;
-
- auto caller = CreatePeerConnection();
- caller->AddAudioTrack("a");
- caller->AddVideoTrack("v");
- auto callee = CreatePeerConnection();
-
- // Caller initially offers to send/recv audio and video.
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- // Callee accepts the audio as recv only but rejects the video.
- ASSERT_TRUE(caller->SetRemoteDescription(
- callee->CreateAnswerAndSetAsLocal(options_reject_video)));
-
- auto caller_voice_send = caller->media_engine()->GetVoiceSendChannel(0);
- auto caller_voice_receive = caller->media_engine()->GetVoiceReceiveChannel(0);
- ASSERT_TRUE(caller_voice_send && caller_voice_receive);
- EXPECT_EQ(0u, caller_voice_receive->recv_streams().size());
- EXPECT_EQ(1u, caller_voice_send->send_streams().size());
- auto caller_video = caller->media_engine()->GetVideoSendChannel(0);
- EXPECT_FALSE(caller_video);
-
- // Callee adds its own audio/video stream and offers to receive audio/video
- // too.
- callee->AddAudioTrack("a");
- auto callee_video_track = callee->AddVideoTrack("v");
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- ASSERT_TRUE(
- caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
-
- auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
- auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
- ASSERT_TRUE(callee_voice_send && callee_voice_receive);
- EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_voice_send->send_streams().size());
- auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
- auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
- ASSERT_TRUE(callee_video_send && callee_video_receive);
- EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_video_send->send_streams().size());
-
- // Callee removes video but keeps audio and rejects the video once again.
- callee->pc()->RemoveTrackOrError(callee_video_track);
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- ASSERT_TRUE(
- callee->SetLocalDescription(callee->CreateAnswer(options_reject_video)));
-
- callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
- callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
- ASSERT_TRUE(callee_voice_send && callee_voice_receive);
- EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_voice_send->send_streams().size());
- auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
- EXPECT_FALSE(callee_video);
-}
-
-// Test that the correct media engine send/recv streams are created when doing
-// a series of offer/answers where audio/video are both sent, then video is
-// rejected, then both audio/video sent again.
-TEST_P(PeerConnectionMediaTest, TestAVOfferWithVideoOnlyAnswer) {
- if (IsUnifiedPlan()) {
- // offer_to_receive_ is not implemented when creating answers with Unified
- // Plan semantics specified.
- return;
- }
-
- // Disable the bundling here. If the media is bundled on audio
- // transport, then we can't reject the audio because switching the bundled
- // transport is not currently supported.
- // (https://bugs.chromium.org/p/webrtc/issues/detail?id=6704)
- RTCOfferAnswerOptions options_no_bundle;
- options_no_bundle.use_rtp_mux = false;
- RTCOfferAnswerOptions options_reject_audio = options_no_bundle;
- options_reject_audio.offer_to_receive_audio = 0;
- options_reject_audio.offer_to_receive_video =
- RTCOfferAnswerOptions::kMaxOfferToReceiveMedia;
-
- auto caller = CreatePeerConnection();
- caller->AddAudioTrack("a");
- caller->AddVideoTrack("v");
- auto callee = CreatePeerConnection();
-
- // Caller initially offers to send/recv audio and video.
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- // Callee accepts the video as recv only but rejects the audio.
- ASSERT_TRUE(caller->SetRemoteDescription(
- callee->CreateAnswerAndSetAsLocal(options_reject_audio)));
-
- auto caller_voice = caller->media_engine()->GetVoiceSendChannel(0);
- EXPECT_FALSE(caller_voice);
- auto caller_video_send = caller->media_engine()->GetVideoSendChannel(0);
- auto caller_video_receive = caller->media_engine()->GetVideoReceiveChannel(0);
- ASSERT_TRUE(caller_video_send && caller_video_receive);
- EXPECT_EQ(0u, caller_video_receive->recv_streams().size());
- EXPECT_EQ(1u, caller_video_send->send_streams().size());
-
- // Callee adds its own audio/video stream and offers to receive audio/video
- // too.
- auto callee_audio_track = callee->AddAudioTrack("a");
- callee->AddVideoTrack("v");
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- ASSERT_TRUE(caller->SetRemoteDescription(
- callee->CreateAnswerAndSetAsLocal(options_no_bundle)));
-
- auto callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
- auto callee_voice_receive = callee->media_engine()->GetVoiceReceiveChannel(0);
- ASSERT_TRUE(callee_voice_send && callee_voice_receive);
- EXPECT_EQ(1u, callee_voice_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_voice_send->send_streams().size());
- auto callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
- auto callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
- ASSERT_TRUE(callee_video_send && callee_video_receive);
- EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_video_send->send_streams().size());
-
- // Callee removes audio but keeps video and rejects the audio once again.
- callee->pc()->RemoveTrackOrError(callee_audio_track);
- ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- ASSERT_TRUE(
- callee->SetLocalDescription(callee->CreateAnswer(options_reject_audio)));
-
- auto callee_voice = callee->media_engine()->GetVoiceReceiveChannel(0);
- EXPECT_FALSE(callee_voice);
- callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
- callee_video_receive = callee->media_engine()->GetVideoReceiveChannel(0);
- ASSERT_TRUE(callee_video_send && callee_video_receive);
- EXPECT_EQ(1u, callee_video_receive->recv_streams().size());
- EXPECT_EQ(1u, callee_video_send->send_streams().size());
-}
-
// Tests that if the underlying video encoder fails to be initialized (signaled
// by failing to set send codecs), the PeerConnection signals the error to the
// client.
-TEST_P(PeerConnectionMediaTest, MediaEngineErrorPropagatedToClients) {
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
+ MediaEngineErrorPropagatedToClients) {
auto caller = CreatePeerConnectionWithAudioVideo();
auto callee = CreatePeerConnectionWithAudioVideo();
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
+ auto video_channel =
+ VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
video_channel->set_fail_set_send_codecs(true);
std::string error;
@@ -1255,14 +1145,15 @@
// Tests that if the underlying video encoder fails once then subsequent
// attempts at setting the local/remote description will also fail, even if
// SetSendCodecs no longer fails.
-TEST_P(PeerConnectionMediaTest,
+TEST_F(PeerConnectionMediaTestUnifiedPlan,
FailToApplyDescriptionIfVideoEncoderHasEverFailed) {
auto caller = CreatePeerConnectionWithAudioVideo();
auto callee = CreatePeerConnectionWithAudioVideo();
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
- auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
+ auto video_channel =
+ VideoMediaSendChannel(caller->pc()->GetTransceivers()[1]);
video_channel->set_fail_set_send_codecs(true);
EXPECT_FALSE(
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 1552982..f659ecf 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -118,39 +118,18 @@
// Create the channels, discard the result; we get them later.
// Fake media channels are owned by the media engine.
- media_engine_->voice().CreateMediaChannel(
- cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
- cricket::AudioOptions(), webrtc::CryptoOptions(),
- webrtc::AudioCodecPairId::Create());
- media_engine_->video().CreateMediaChannel(
- cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
- cricket::VideoOptions(), webrtc::CryptoOptions(),
- video_bitrate_allocator_factory_.get());
- media_engine_->voice().CreateMediaChannel(
- cricket::MediaChannel::Role::kReceive, &fake_call_,
- cricket::MediaConfig(), cricket::AudioOptions(),
+ voice_media_send_channel_ = media_engine_->voice().CreateSendChannel(
+ &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
- media_engine_->video().CreateMediaChannel(
- cricket::MediaChannel::Role::kReceive, &fake_call_,
- cricket::MediaConfig(), cricket::VideoOptions(),
+ video_media_send_channel_ = media_engine_->video().CreateSendChannel(
+ &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
-
- voice_media_send_channel_ =
- absl::WrapUnique(media_engine_->GetVoiceSendChannel(0));
- video_media_send_channel_ =
- absl::WrapUnique(media_engine_->GetVideoSendChannel(0));
- voice_media_receive_channel_ =
- absl::WrapUnique(media_engine_->GetVoiceReceiveChannel(0));
- video_media_receive_channel_ =
- absl::WrapUnique(media_engine_->GetVideoReceiveChannel(0));
-
- RTC_CHECK(voice_media_send_channel());
- RTC_CHECK(video_media_send_channel());
- RTC_CHECK(voice_media_receive_channel());
- RTC_CHECK(video_media_receive_channel());
- // Create sender channel objects
- voice_send_channel_ = voice_media_send_channel()->AsVoiceSendChannel();
- video_send_channel_ = video_media_send_channel()->AsVideoSendChannel();
+ voice_media_receive_channel_ = media_engine_->voice().CreateReceiveChannel(
+ &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
+ webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
+ video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel(
+ &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
+ webrtc::CryptoOptions());
// Create streams for predefined SSRCs. Streams need to exist in order
// for the senders and receievers to apply parameters to them.
@@ -225,7 +204,7 @@
ASSERT_TRUE(audio_rtp_sender_->SetTrack(audio_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams());
audio_rtp_sender_->SetStreams({local_stream_->id()});
- audio_rtp_sender_->SetMediaChannel(voice_send_channel_);
+ audio_rtp_sender_->SetMediaChannel(voice_media_send_channel_.get());
audio_rtp_sender_->SetSsrc(kAudioSsrc);
VerifyVoiceChannelInput();
}
@@ -233,8 +212,7 @@
void CreateAudioRtpSenderWithNoTrack() {
audio_rtp_sender_ =
AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
- audio_rtp_sender_->SetMediaChannel(
- voice_media_send_channel()->AsVoiceSendChannel());
+ audio_rtp_sender_->SetMediaChannel(voice_media_send_channel_.get());
}
void CreateVideoRtpSender(uint32_t ssrc) {
@@ -286,16 +264,14 @@
ASSERT_TRUE(video_rtp_sender_->SetTrack(video_track_.get()));
EXPECT_CALL(*set_streams_observer, OnSetStreams());
video_rtp_sender_->SetStreams({local_stream_->id()});
- video_rtp_sender_->SetMediaChannel(
- video_media_send_channel()->AsVideoSendChannel());
+ video_rtp_sender_->SetMediaChannel(video_media_send_channel());
video_rtp_sender_->SetSsrc(ssrc);
VerifyVideoChannelInput(ssrc);
}
void CreateVideoRtpSenderWithNoTrack() {
video_rtp_sender_ =
VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
- video_rtp_sender_->SetMediaChannel(
- video_media_send_channel()->AsVideoSendChannel());
+ video_rtp_sender_->SetMediaChannel(video_media_send_channel());
}
void DestroyAudioRtpSender() {
@@ -313,8 +289,7 @@
audio_rtp_receiver_ = rtc::make_ref_counted<AudioRtpReceiver>(
rtc::Thread::Current(), kAudioTrackId, streams,
/*is_unified_plan=*/true);
- audio_rtp_receiver_->SetMediaChannel(
- voice_media_receive_channel()->AsVoiceReceiveChannel());
+ audio_rtp_receiver_->SetMediaChannel(voice_media_receive_channel());
audio_rtp_receiver_->SetupMediaChannel(kAudioSsrc);
audio_track_ = audio_rtp_receiver_->audio_track();
VerifyVoiceChannelOutput();
@@ -324,8 +299,7 @@
std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams = {}) {
video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
rtc::Thread::Current(), kVideoTrackId, streams);
- video_rtp_receiver_->SetMediaChannel(
- video_media_receive_channel()->AsVideoReceiveChannel());
+ video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
video_rtp_receiver_->SetupMediaChannel(kVideoSsrc);
video_track_ = video_rtp_receiver_->video_track();
VerifyVideoChannelOutput();
@@ -345,8 +319,7 @@
video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
rtc::Thread::Current(), kVideoTrackId, streams);
- video_rtp_receiver_->SetMediaChannel(
- video_media_receive_channel()->AsVideoReceiveChannel());
+ video_rtp_receiver_->SetMediaChannel(video_media_receive_channel());
video_rtp_receiver_->SetupMediaChannel(primary_ssrc);
video_track_ = video_rtp_receiver_->video_track();
}
@@ -381,7 +354,7 @@
void VerifyVideoChannelInput(uint32_t ssrc) {
// Verify that the media channel has a video source,
- EXPECT_TRUE(video_media_send_channel_->HasSource(ssrc));
+ EXPECT_TRUE(video_media_send_channel()->HasSource(ssrc));
}
void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); }
@@ -395,7 +368,7 @@
void VerifyVideoChannelNoInput(uint32_t ssrc) {
// Verify that the media channel's source is reset.
- EXPECT_FALSE(video_media_receive_channel_->HasSource(ssrc));
+ EXPECT_FALSE(video_media_receive_channel()->HasSource(ssrc));
}
void VerifyVoiceChannelOutput() {
@@ -408,7 +381,7 @@
void VerifyVideoChannelOutput() {
// Verify that the media channel has a sink.
- EXPECT_TRUE(video_media_receive_channel_->HasSink(kVideoSsrc));
+ EXPECT_TRUE(video_media_receive_channel()->HasSink(kVideoSsrc));
}
void VerifyVoiceChannelNoOutput() {
@@ -421,7 +394,7 @@
void VerifyVideoChannelNoOutput() {
// Verify that the media channel's sink is reset.
- EXPECT_FALSE(video_media_receive_channel_->HasSink(kVideoSsrc));
+ EXPECT_FALSE(video_media_receive_channel()->HasSink(kVideoSsrc));
}
// Verifies that the encoding layers contain the specified RIDs.
@@ -522,17 +495,21 @@
}
protected:
- cricket::FakeVideoMediaChannel* video_media_send_channel() {
- return video_media_send_channel_.get();
+ cricket::FakeVideoMediaSendChannel* video_media_send_channel() {
+ return static_cast<cricket::FakeVideoMediaSendChannel*>(
+ video_media_send_channel_.get());
}
- cricket::FakeVoiceMediaChannel* voice_media_send_channel() {
- return voice_media_send_channel_.get();
+ cricket::FakeVoiceMediaSendChannel* voice_media_send_channel() {
+ return static_cast<cricket::FakeVoiceMediaSendChannel*>(
+ voice_media_send_channel_.get());
}
- cricket::FakeVideoMediaChannel* video_media_receive_channel() {
- return video_media_receive_channel_.get();
+ cricket::FakeVideoMediaReceiveChannel* video_media_receive_channel() {
+ return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
+ video_media_receive_channel_.get());
}
- cricket::FakeVoiceMediaChannel* voice_media_receive_channel() {
- return voice_media_receive_channel_.get();
+ cricket::FakeVoiceMediaReceiveChannel* voice_media_receive_channel() {
+ return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
+ voice_media_receive_channel_.get());
}
test::RunLoop run_loop_;
@@ -548,12 +525,14 @@
std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
rtc::UniqueRandomIdGenerator ssrc_generator_;
cricket::FakeCall fake_call_;
- std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_send_channel_;
- std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_send_channel_;
- std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_receive_channel_;
- std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_receive_channel_;
- cricket::VoiceMediaSendChannelInterface* voice_send_channel_;
- cricket::VideoMediaSendChannelInterface* video_send_channel_;
+ std::unique_ptr<cricket::VoiceMediaSendChannelInterface>
+ voice_media_send_channel_;
+ std::unique_ptr<cricket::VideoMediaSendChannelInterface>
+ video_media_send_channel_;
+ std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+ voice_media_receive_channel_;
+ std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+ video_media_receive_channel_;
rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
diff --git a/pc/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index d1bf578..8948b7c 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -25,6 +25,7 @@
#include "api/rtp_parameters.h"
#include "api/sequence_checker.h"
#include "media/base/codec.h"
+#include "media/base/media_channel.h"
#include "media/base/media_channel_impl.h"
#include "media/base/media_constants.h"
#include "media/base/media_engine.h"
@@ -219,18 +220,19 @@
AudioCodecPairId codec_pair_id = AudioCodecPairId::Create();
if (use_split_media_channel) {
- std::unique_ptr<cricket::VoiceMediaChannel> media_send_channel =
- absl::WrapUnique(media_engine()->voice().CreateMediaChannel(
- cricket::MediaChannel::Role::kSend, call_ptr, media_config,
- audio_options, crypto_options, codec_pair_id));
+ std::unique_ptr<cricket::VoiceMediaSendChannelInterface>
+ media_send_channel = media_engine()->voice().CreateSendChannel(
+ call_ptr, media_config, audio_options, crypto_options,
+ codec_pair_id);
if (!media_send_channel) {
// TODO(bugs.webrtc.org/14912): Consider CHECK or reporting failure
return;
}
- std::unique_ptr<cricket::VoiceMediaChannel> media_receive_channel =
- absl::WrapUnique(media_engine()->voice().CreateMediaChannel(
- cricket::MediaChannel::Role::kReceive, call_ptr, media_config,
- audio_options, crypto_options, codec_pair_id));
+ std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+ media_receive_channel =
+ media_engine()->voice().CreateReceiveChannel(
+ call_ptr, media_config, audio_options, crypto_options,
+ codec_pair_id);
if (!media_receive_channel) {
return;
}
@@ -272,20 +274,18 @@
RTC_DCHECK_RUN_ON(context()->worker_thread());
if (use_split_media_channel) {
- std::unique_ptr<cricket::VideoMediaChannel> media_send_channel =
- absl::WrapUnique(media_engine()->video().CreateMediaChannel(
- cricket::MediaChannel::Role::kSend, call_ptr, media_config,
- video_options, crypto_options,
- video_bitrate_allocator_factory));
+ std::unique_ptr<cricket::VideoMediaSendChannelInterface>
+ media_send_channel = media_engine()->video().CreateSendChannel(
+ call_ptr, media_config, video_options, crypto_options,
+ video_bitrate_allocator_factory);
if (!media_send_channel) {
return;
}
- std::unique_ptr<cricket::VideoMediaChannel> media_receive_channel =
- absl::WrapUnique(media_engine()->video().CreateMediaChannel(
- cricket::MediaChannel::Role::kReceive, call_ptr, media_config,
- video_options, crypto_options,
- video_bitrate_allocator_factory));
+ std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+ media_receive_channel =
+ media_engine()->video().CreateReceiveChannel(
+ call_ptr, media_config, video_options, crypto_options);
if (!media_receive_channel) {
return;
}
diff --git a/pc/test/fake_peer_connection_for_stats.h b/pc/test/fake_peer_connection_for_stats.h
index 79be6a0..7302182 100644
--- a/pc/test/fake_peer_connection_for_stats.h
+++ b/pc/test/fake_peer_connection_for_stats.h
@@ -19,6 +19,7 @@
#include <vector>
#include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
#include "pc/channel.h"
#include "pc/stream_collection.h"
#include "pc/test/fake_data_channel_controller.h"
@@ -27,89 +28,49 @@
namespace webrtc {
// Fake VoiceMediaChannel where the result of GetStats can be configured.
-class FakeVoiceMediaChannelForStats : public cricket::FakeVoiceMediaChannel {
+class FakeVoiceMediaSendChannelForStats
+ : public cricket::FakeVoiceMediaSendChannel {
public:
- explicit FakeVoiceMediaChannelForStats(MediaChannel::Role role,
- TaskQueueBase* network_thread)
- : cricket::FakeVoiceMediaChannel(role,
- nullptr,
- cricket::AudioOptions(),
- network_thread) {}
+ explicit FakeVoiceMediaSendChannelForStats(TaskQueueBase* network_thread)
+ : cricket::FakeVoiceMediaSendChannel(cricket::AudioOptions(),
+ network_thread) {}
void SetStats(const cricket::VoiceMediaInfo& voice_info) {
send_stats_ = cricket::VoiceMediaSendInfo();
send_stats_->senders = voice_info.senders;
send_stats_->send_codecs = voice_info.send_codecs;
- receive_stats_ = cricket::VoiceMediaReceiveInfo();
- receive_stats_->receivers = voice_info.receivers;
- receive_stats_->receive_codecs = voice_info.receive_codecs;
- receive_stats_->device_underrun_count = voice_info.device_underrun_count;
}
// VoiceMediaChannel overrides.
- bool GetSendStats(cricket::VoiceMediaSendInfo* info) override {
- RTC_DCHECK(role() == MediaChannel::Role::kSend);
+ bool GetStats(cricket::VoiceMediaSendInfo* info) override {
if (send_stats_) {
*info = *send_stats_;
return true;
}
return false;
}
- bool GetReceiveStats(cricket::VoiceMediaReceiveInfo* info,
- bool get_and_clear_legacy_stats) override {
- RTC_DCHECK(role() == MediaChannel::Role::kReceive);
- if (receive_stats_) {
- *info = *receive_stats_;
- return true;
- }
- return false;
- }
private:
absl::optional<cricket::VoiceMediaSendInfo> send_stats_;
- absl::optional<cricket::VoiceMediaReceiveInfo> receive_stats_;
};
-// Fake VideoMediaChannel where the result of GetStats can be configured.
-class FakeVideoMediaChannelForStats : public cricket::FakeVideoMediaChannel {
+class FakeVoiceMediaReceiveChannelForStats
+ : public cricket::FakeVoiceMediaReceiveChannel {
public:
- explicit FakeVideoMediaChannelForStats(cricket::MediaChannel::Role role,
- TaskQueueBase* network_thread)
- : cricket::FakeVideoMediaChannel(role,
- nullptr,
- cricket::VideoOptions(),
- network_thread) {}
+ explicit FakeVoiceMediaReceiveChannelForStats(TaskQueueBase* network_thread)
+ : cricket::FakeVoiceMediaReceiveChannel(cricket::AudioOptions(),
+ network_thread) {}
- void SetStats(const cricket::VideoMediaInfo& video_info) {
- switch (role()) {
- case MediaChannel::Role::kSend:
- send_stats_ = cricket::VideoMediaSendInfo();
- send_stats_->senders = video_info.senders;
- send_stats_->aggregated_senders = video_info.aggregated_senders;
- send_stats_->send_codecs = video_info.send_codecs;
- break;
- case MediaChannel::Role::kReceive:
- receive_stats_ = cricket::VideoMediaReceiveInfo();
- receive_stats_->receivers = video_info.receivers;
- receive_stats_->receive_codecs = video_info.receive_codecs;
- break;
- default:
- RTC_CHECK_NOTREACHED();
- }
+ void SetStats(const cricket::VoiceMediaInfo& voice_info) {
+ receive_stats_ = cricket::VoiceMediaReceiveInfo();
+ receive_stats_->receivers = voice_info.receivers;
+ receive_stats_->receive_codecs = voice_info.receive_codecs;
+ receive_stats_->device_underrun_count = voice_info.device_underrun_count;
}
- // VideoMediaChannel overrides.
- bool GetSendStats(cricket::VideoMediaSendInfo* info) override {
- RTC_DCHECK(role() == MediaChannel::Role::kSend);
-
- if (send_stats_) {
- *info = *send_stats_;
- return true;
- }
- return false;
- }
- bool GetReceiveStats(cricket::VideoMediaReceiveInfo* info) override {
- RTC_DCHECK(role() == MediaChannel::Role::kReceive);
+ // VoiceMediaChannel overrides.
+ bool GetStats(cricket::VoiceMediaReceiveInfo* info,
+ bool get_and_clear_legacy_stats) override {
if (receive_stats_) {
*info = *receive_stats_;
return true;
@@ -118,7 +79,60 @@
}
private:
+ absl::optional<cricket::VoiceMediaReceiveInfo> receive_stats_;
+};
+
+// Fake VideoMediaChannel where the result of GetStats can be configured.
+class FakeVideoMediaSendChannelForStats
+ : public cricket::FakeVideoMediaSendChannel {
+ public:
+ explicit FakeVideoMediaSendChannelForStats(TaskQueueBase* network_thread)
+ : cricket::FakeVideoMediaSendChannel(cricket::VideoOptions(),
+ network_thread) {}
+
+ void SetStats(const cricket::VideoMediaInfo& video_info) {
+ send_stats_ = cricket::VideoMediaSendInfo();
+ send_stats_->senders = video_info.senders;
+ send_stats_->aggregated_senders = video_info.aggregated_senders;
+ send_stats_->send_codecs = video_info.send_codecs;
+ }
+
+ // VideoMediaChannel overrides.
+ bool GetStats(cricket::VideoMediaSendInfo* info) override {
+ if (send_stats_) {
+ *info = *send_stats_;
+ return true;
+ }
+ return false;
+ }
+
+ private:
absl::optional<cricket::VideoMediaSendInfo> send_stats_;
+};
+
+class FakeVideoMediaReceiveChannelForStats
+ : public cricket::FakeVideoMediaReceiveChannel {
+ public:
+ explicit FakeVideoMediaReceiveChannelForStats(TaskQueueBase* network_thread)
+ : cricket::FakeVideoMediaReceiveChannel(cricket::VideoOptions(),
+ network_thread) {}
+
+ void SetStats(const cricket::VideoMediaInfo& video_info) {
+ receive_stats_ = cricket::VideoMediaReceiveInfo();
+ receive_stats_->receivers = video_info.receivers;
+ receive_stats_->receive_codecs = video_info.receive_codecs;
+ }
+
+ // VideoMediaChannel overrides.
+ bool GetStats(cricket::VideoMediaReceiveInfo* info) override {
+ if (receive_stats_) {
+ *info = *receive_stats_;
+ return true;
+ }
+ return false;
+ }
+
+ private:
absl::optional<cricket::VideoMediaReceiveInfo> receive_stats_;
};
@@ -131,8 +145,9 @@
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
- std::unique_ptr<cricket::VoiceMediaChannel> send_channel,
- std::unique_ptr<cricket::VoiceMediaChannel> receive_channel,
+ std::unique_ptr<cricket::VoiceMediaSendChannelInterface> send_channel,
+ std::unique_ptr<cricket::VoiceMediaReceiveChannelInterface>
+ receive_channel,
const std::string& content_name,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
@@ -163,8 +178,9 @@
rtc::Thread* worker_thread,
rtc::Thread* network_thread,
rtc::Thread* signaling_thread,
- std::unique_ptr<cricket::VideoMediaChannel> send_channel,
- std::unique_ptr<cricket::VideoMediaChannel> receive_channel,
+ std::unique_ptr<cricket::VideoMediaSendChannelInterface> send_channel,
+ std::unique_ptr<cricket::VideoMediaReceiveChannelInterface>
+ receive_channel,
const std::string& content_name,
bool srtp_required,
webrtc::CryptoOptions crypto_options,
@@ -266,17 +282,16 @@
->RemoveReceiver(receiver.get());
}
- std::pair<FakeVoiceMediaChannelForStats*, FakeVoiceMediaChannelForStats*>
+ std::pair<FakeVoiceMediaSendChannelForStats*,
+ FakeVoiceMediaReceiveChannelForStats*>
AddVoiceChannel(
const std::string& mid,
const std::string& transport_name,
cricket::VoiceMediaInfo initial_stats = cricket::VoiceMediaInfo()) {
auto voice_media_send_channel =
- std::make_unique<FakeVoiceMediaChannelForStats>(
- cricket::MediaChannel::Role::kSend, network_thread_);
+ std::make_unique<FakeVoiceMediaSendChannelForStats>(network_thread_);
auto voice_media_receive_channel =
- std::make_unique<FakeVoiceMediaChannelForStats>(
- cricket::MediaChannel::Role::kReceive, network_thread_);
+ std::make_unique<FakeVoiceMediaReceiveChannelForStats>(network_thread_);
auto* voice_media_send_channel_ptr = voice_media_send_channel.get();
auto* voice_media_receive_channel_ptr = voice_media_receive_channel.get();
auto voice_channel = std::make_unique<VoiceChannelForTesting>(
@@ -301,17 +316,16 @@
voice_media_receive_channel_ptr);
}
- std::pair<FakeVideoMediaChannelForStats*, FakeVideoMediaChannelForStats*>
+ std::pair<FakeVideoMediaSendChannelForStats*,
+ FakeVideoMediaReceiveChannelForStats*>
AddVideoChannel(
const std::string& mid,
const std::string& transport_name,
cricket::VideoMediaInfo initial_stats = cricket::VideoMediaInfo()) {
auto video_media_send_channel =
- std::make_unique<FakeVideoMediaChannelForStats>(
- cricket::MediaChannel::Role::kSend, network_thread_);
+ std::make_unique<FakeVideoMediaSendChannelForStats>(network_thread_);
auto video_media_receive_channel =
- std::make_unique<FakeVideoMediaChannelForStats>(
- cricket::MediaChannel::Role::kReceive, network_thread_);
+ std::make_unique<FakeVideoMediaReceiveChannelForStats>(network_thread_);
auto video_media_send_channel_ptr = video_media_send_channel.get();
auto video_media_receive_channel_ptr = video_media_receive_channel.get();
auto video_channel = std::make_unique<VideoChannelForTesting>(
diff --git a/pc/video_rtp_receiver_unittest.cc b/pc/video_rtp_receiver_unittest.cc
index 5efd6df..5ff7360 100644
--- a/pc/video_rtp_receiver_unittest.cc
+++ b/pc/video_rtp_receiver_unittest.cc
@@ -17,6 +17,7 @@
#include "api/video/recordable_encoded_frame.h"
#include "api/video/test/mock_recordable_encoded_frame.h"
#include "media/base/fake_media_engine.h"
+#include "media/base/media_channel.h"
#include "rtc_base/task_queue_for_test.h"
#include "test/gmock.h"
#include "test/gtest.h"
@@ -34,16 +35,25 @@
class VideoRtpReceiverTest : public testing::Test {
protected:
- class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
+ class MockVideoMediaSendChannel : public cricket::FakeVideoMediaSendChannel {
public:
- MockVideoMediaChannel(
- cricket::FakeVideoEngine* engine,
+ MockVideoMediaSendChannel(
const cricket::VideoOptions& options,
TaskQueueBase* network_thread = rtc::Thread::Current())
- : FakeVideoMediaChannel(cricket::MediaChannel::Role::kBoth,
- engine,
- options,
- network_thread) {}
+ : FakeVideoMediaSendChannel(options, network_thread) {}
+ MOCK_METHOD(void,
+ GenerateSendKeyFrame,
+ (uint32_t, const std::vector<std::string>&),
+ (override));
+ };
+
+ class MockVideoMediaReceiveChannel
+ : public cricket::FakeVideoMediaReceiveChannel {
+ public:
+ MockVideoMediaReceiveChannel(
+ const cricket::VideoOptions& options,
+ TaskQueueBase* network_thread = rtc::Thread::Current())
+ : FakeVideoMediaReceiveChannel(options, network_thread) {}
MOCK_METHOD(void,
SetRecordableEncodedFrameCallback,
(uint32_t, std::function<void(const RecordableEncodedFrame&)>),
@@ -53,10 +63,6 @@
(uint32_t),
(override));
MOCK_METHOD(void, RequestRecvKeyFrame, (uint32_t), (override));
- MOCK_METHOD(void,
- GenerateSendKeyFrame,
- (uint32_t, const std::vector<std::string>&),
- (override));
};
class MockVideoSink : public rtc::VideoSinkInterface<RecordableEncodedFrame> {
@@ -66,7 +72,7 @@
VideoRtpReceiverTest()
: worker_thread_(rtc::Thread::Create()),
- channel_(nullptr, cricket::VideoOptions()),
+ channel_(cricket::VideoOptions()),
receiver_(rtc::make_ref_counted<VideoRtpReceiver>(
worker_thread_.get(),
std::string("receiver"),
@@ -83,7 +89,7 @@
SetMediaChannel(nullptr);
}
- void SetMediaChannel(cricket::MediaChannel* media_channel) {
+ void SetMediaChannel(cricket::MediaReceiveChannelInterface* media_channel) {
SendTask(worker_thread_.get(),
[&]() { receiver_->SetMediaChannel(media_channel); });
}
@@ -94,7 +100,7 @@
rtc::AutoThread main_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
- NiceMock<MockVideoMediaChannel> channel_;
+ NiceMock<MockVideoMediaReceiveChannel> channel_;
rtc::scoped_refptr<VideoRtpReceiver> receiver_;
};
@@ -111,7 +117,7 @@
GenerateKeyFrameOnChannelSwitchUnlessGenerateKeyframeCalled) {
// A channel switch without previous call to GenerateKeyFrame shouldn't
// cause a call to happen on the new channel.
- MockVideoMediaChannel channel2(nullptr, cricket::VideoOptions());
+ MockVideoMediaReceiveChannel channel2{cricket::VideoOptions()};
EXPECT_CALL(channel_, RequestRecvKeyFrame).Times(0);
EXPECT_CALL(channel2, RequestRecvKeyFrame).Times(0);
SetMediaChannel(&channel2);
@@ -121,12 +127,12 @@
// re-generate it as we don't know if it was eventually received
EXPECT_CALL(channel2, RequestRecvKeyFrame).Times(1);
Source()->GenerateKeyFrame();
- MockVideoMediaChannel channel3(nullptr, cricket::VideoOptions());
+ MockVideoMediaReceiveChannel channel3{cricket::VideoOptions()};
EXPECT_CALL(channel3, RequestRecvKeyFrame);
SetMediaChannel(&channel3);
// Switching to a new channel should now not cause calls to GenerateKeyFrame.
- StrictMock<MockVideoMediaChannel> channel4(nullptr, cricket::VideoOptions());
+ StrictMock<MockVideoMediaReceiveChannel> channel4{cricket::VideoOptions()};
SetMediaChannel(&channel4);
// We must call SetMediaChannel(nullptr) here since the mock media channels
@@ -154,7 +160,7 @@
EXPECT_CALL(channel_, ClearRecordableEncodedFrameCallback);
MockVideoSink sink;
Source()->AddEncodedSink(&sink);
- MockVideoMediaChannel channel2(nullptr, cricket::VideoOptions());
+ MockVideoMediaReceiveChannel channel2{cricket::VideoOptions()};
EXPECT_CALL(channel2, SetRecordableEncodedFrameCallback);
SetMediaChannel(&channel2);
Mock::VerifyAndClearExpectations(&channel2);
@@ -163,7 +169,7 @@
// to NOT set the callback again.
EXPECT_CALL(channel2, ClearRecordableEncodedFrameCallback);
Source()->RemoveEncodedSink(&sink);
- StrictMock<MockVideoMediaChannel> channel3(nullptr, cricket::VideoOptions());
+ StrictMock<MockVideoMediaReceiveChannel> channel3{cricket::VideoOptions()};
SetMediaChannel(&channel3);
// We must call SetMediaChannel(nullptr) here since the mock media channels
