Change FakeMediaEngine to use send/receive channels
Also update the tests that depend on FakeMediaEngine. Bug: webrtc:13931 Change-Id: Ia608c4ce68a29e45174b68ba0103af31e9a7d3d1 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/294280 Reviewed-by: Henrik Boström <hbos@webrtc.org> Commit-Queue: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/main@{#39345}
This commit is contained in:
Harald Alvestrand
WebRTC LUCI CQ
parent
b337c40e58
commit
70429d45a6
@ -463,14 +463,36 @@ VoiceMediaChannel* FakeVoiceEngine::CreateMediaChannel(
|
||||
|
||||
FakeVoiceMediaChannel* ch =
|
||||
new FakeVoiceMediaChannel(role, this, options, call->network_thread());
|
||||
channels_.push_back(ch);
|
||||
switch (role) {
|
||||
case MediaChannel::Role::kSend:
|
||||
send_channels_.push_back(ch);
|
||||
break;
|
||||
case MediaChannel::Role::kReceive:
|
||||
receive_channels_.push_back(ch);
|
||||
break;
|
||||
default:
|
||||
// kBoth isn't supported any more.
|
||||
RTC_CHECK_NOTREACHED();
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
FakeVoiceMediaChannel* FakeVoiceEngine::GetChannel(size_t index) {
|
||||
return (channels_.size() > index) ? channels_[index] : NULL;
|
||||
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) {
|
||||
channels_.erase(absl::c_find(channels_, 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;
|
||||
default:
|
||||
RTC_CHECK_NOTREACHED();
|
||||
}
|
||||
}
|
||||
const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
|
||||
return send_codecs_;
|
||||
@ -535,16 +557,41 @@ VideoMediaChannel* FakeVideoEngine::CreateMediaChannel(
|
||||
|
||||
FakeVideoMediaChannel* ch =
|
||||
new FakeVideoMediaChannel(role, this, options, call->network_thread());
|
||||
channels_.emplace_back(ch);
|
||||
switch (role) {
|
||||
case MediaChannel::Role::kSend:
|
||||
send_channels_.emplace_back(ch);
|
||||
break;
|
||||
case MediaChannel::Role::kReceive:
|
||||
receive_channels_.emplace_back(ch);
|
||||
break;
|
||||
default:
|
||||
// kBoth isn't supported
|
||||
RTC_CHECK_NOTREACHED();
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
FakeVideoMediaChannel* FakeVideoEngine::GetChannel(size_t index) {
|
||||
return (channels_.size() > index) ? channels_[index] : nullptr;
|
||||
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) {
|
||||
auto it = absl::c_find(channels_, channel);
|
||||
RTC_DCHECK(it != channels_.end());
|
||||
channels_.erase(it);
|
||||
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;
|
||||
default:
|
||||
RTC_CHECK_NOTREACHED();
|
||||
}
|
||||
}
|
||||
std::vector<VideoCodec> FakeVideoEngine::send_codecs(bool use_rtx) const {
|
||||
return send_codecs_;
|
||||
@ -597,11 +644,17 @@ void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
|
||||
video_->SetRecvCodecs(codecs);
|
||||
}
|
||||
|
||||
FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) {
|
||||
return voice_->GetChannel(index);
|
||||
FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceSendChannel(size_t index) {
|
||||
return voice_->GetSendChannel(index);
|
||||
}
|
||||
FakeVideoMediaChannel* FakeMediaEngine::GetVideoChannel(size_t index) {
|
||||
return video_->GetChannel(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) {
|
||||
|
||||
@ -543,7 +543,8 @@ class FakeVoiceEngine : public VoiceEngineInterface {
|
||||
const AudioOptions& options,
|
||||
const webrtc::CryptoOptions& crypto_options,
|
||||
webrtc::AudioCodecPairId codec_pair_id) override;
|
||||
FakeVoiceMediaChannel* GetChannel(size_t index);
|
||||
FakeVoiceMediaChannel* GetSendChannel(size_t index);
|
||||
FakeVoiceMediaChannel* GetReceiveChannel(size_t index);
|
||||
void UnregisterChannel(VoiceMediaChannel* channel);
|
||||
|
||||
// TODO(ossu): For proper testing, These should either individually settable
|
||||
@ -564,7 +565,8 @@ class FakeVoiceEngine : public VoiceEngineInterface {
|
||||
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
|
||||
|
||||
private:
|
||||
std::vector<FakeVoiceMediaChannel*> channels_;
|
||||
std::vector<FakeVoiceMediaChannel*> send_channels_;
|
||||
std::vector<FakeVoiceMediaChannel*> receive_channels_;
|
||||
std::vector<AudioCodec> recv_codecs_;
|
||||
std::vector<AudioCodec> send_codecs_;
|
||||
bool fail_create_channel_;
|
||||
@ -585,7 +587,8 @@ class FakeVideoEngine : public VideoEngineInterface {
|
||||
const webrtc::CryptoOptions& crypto_options,
|
||||
webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
|
||||
override;
|
||||
FakeVideoMediaChannel* GetChannel(size_t index);
|
||||
FakeVideoMediaChannel* GetSendChannel(size_t index);
|
||||
FakeVideoMediaChannel* GetReceiveChannel(size_t index);
|
||||
void UnregisterChannel(VideoMediaChannel* channel);
|
||||
std::vector<VideoCodec> send_codecs() const override {
|
||||
return send_codecs(true);
|
||||
@ -604,7 +607,8 @@ class FakeVideoEngine : public VideoEngineInterface {
|
||||
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
|
||||
|
||||
private:
|
||||
std::vector<FakeVideoMediaChannel*> channels_;
|
||||
std::vector<FakeVideoMediaChannel*> send_channels_;
|
||||
std::vector<FakeVideoMediaChannel*> receive_channels_;
|
||||
std::vector<VideoCodec> send_codecs_;
|
||||
std::vector<VideoCodec> recv_codecs_;
|
||||
bool capture_;
|
||||
@ -626,8 +630,10 @@ class FakeMediaEngine : public CompositeMediaEngine {
|
||||
void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs);
|
||||
void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
|
||||
|
||||
FakeVoiceMediaChannel* GetVoiceChannel(size_t index);
|
||||
FakeVideoMediaChannel* GetVideoChannel(size_t index);
|
||||
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);
|
||||
|
||||
|
||||
@ -39,7 +39,8 @@ class AudioRtpReceiverTest : public ::testing::Test {
|
||||
std::string(),
|
||||
std::vector<std::string>(),
|
||||
false)),
|
||||
media_channel_(rtc::Thread::Current()) {
|
||||
media_channel_(cricket::MediaChannel::Role::kReceive,
|
||||
rtc::Thread::Current()) {
|
||||
EXPECT_CALL(media_channel_, SetRawAudioSink(kSsrc, _));
|
||||
EXPECT_CALL(media_channel_, SetBaseMinimumPlayoutDelayMs(kSsrc, _));
|
||||
}
|
||||
@ -101,7 +102,8 @@ TEST_F(AudioRtpReceiverTest, VolumesSetBeforeStartingAreRespected) {
|
||||
TEST(AudioRtpReceiver, OnChangedNotificationsAfterConstruction) {
|
||||
webrtc::test::RunLoop loop;
|
||||
auto* thread = rtc::Thread::Current(); // Points to loop's thread.
|
||||
cricket::MockVoiceMediaChannel media_channel(thread);
|
||||
cricket::MockVoiceMediaChannel media_channel(
|
||||
cricket::MediaChannel::Role::kReceive, thread);
|
||||
auto receiver = rtc::make_ref_counted<AudioRtpReceiver>(
|
||||
thread, std::string(), std::vector<std::string>(), true, &media_channel);
|
||||
|
||||
|
||||
@ -290,29 +290,33 @@ TEST_P(PeerConnectionMediaTest, AudioVideoOfferAnswerCreateSendRecvStreams) {
|
||||
ASSERT_TRUE(
|
||||
caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
|
||||
|
||||
auto* caller_voice_send = caller->media_engine()->GetVoiceChannel(0);
|
||||
auto* caller_voice_receive = caller->media_engine()->GetVoiceChannel(1);
|
||||
auto* caller_voice_send = caller->media_engine()->GetVoiceSendChannel(0);
|
||||
auto* caller_voice_receive =
|
||||
caller->media_engine()->GetVoiceReceiveChannel(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()->GetVideoChannel(0);
|
||||
auto* caller_video_receive = caller->media_engine()->GetVideoChannel(1);
|
||||
auto* caller_video_send = caller->media_engine()->GetVideoSendChannel(0);
|
||||
auto* caller_video_receive =
|
||||
caller->media_engine()->GetVideoReceiveChannel(0);
|
||||
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()->GetVoiceChannel(0);
|
||||
auto* callee_voice_receive = callee->media_engine()->GetVoiceChannel(1);
|
||||
auto* callee_voice_send = callee->media_engine()->GetVoiceSendChannel(0);
|
||||
auto* callee_voice_receive =
|
||||
callee->media_engine()->GetVoiceReceiveChannel(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()->GetVideoChannel(0);
|
||||
auto* callee_video_receive = callee->media_engine()->GetVideoChannel(1);
|
||||
auto* callee_video_send = callee->media_engine()->GetVideoSendChannel(0);
|
||||
auto* callee_video_receive =
|
||||
callee->media_engine()->GetVideoReceiveChannel(0);
|
||||
EXPECT_THAT(GetIds(callee_video_receive->recv_streams()),
|
||||
ElementsAre(kCallerVideoId));
|
||||
EXPECT_THAT(GetIds(callee_video_send->send_streams()),
|
||||
@ -338,8 +342,10 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
|
||||
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
|
||||
|
||||
ASSERT_FALSE(callee->media_engine()->GetVoiceChannel(0));
|
||||
ASSERT_FALSE(callee->media_engine()->GetVideoChannel(0));
|
||||
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));
|
||||
}
|
||||
|
||||
// Test that removing streams from a subsequent offer causes the receive streams
|
||||
@ -359,12 +365,14 @@ TEST_F(PeerConnectionMediaTestPlanB, EmptyRemoteOfferRemovesRecvStreams) {
|
||||
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
|
||||
|
||||
auto callee_voice = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_video = callee->media_engine()->GetVideoChannel(0);
|
||||
EXPECT_EQ(1u, callee_voice->send_streams().size());
|
||||
EXPECT_EQ(0u, callee_voice->recv_streams().size());
|
||||
EXPECT_EQ(1u, callee_video->send_streams().size());
|
||||
EXPECT_EQ(0u, callee_video->recv_streams().size());
|
||||
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());
|
||||
}
|
||||
|
||||
// Test enabling of simulcast with Plan B semantics.
|
||||
@ -436,8 +444,8 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
|
||||
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
|
||||
|
||||
EXPECT_FALSE(callee->media_engine()->GetVoiceChannel(0));
|
||||
EXPECT_FALSE(callee->media_engine()->GetVideoChannel(0));
|
||||
EXPECT_FALSE(callee->media_engine()->GetVoiceReceiveChannel(0));
|
||||
EXPECT_FALSE(callee->media_engine()->GetVideoReceiveChannel(0));
|
||||
}
|
||||
|
||||
// Test that removing streams from a subsequent answer causes the send streams
|
||||
@ -457,10 +465,10 @@ TEST_F(PeerConnectionMediaTestPlanB, EmptyLocalAnswerRemovesSendStreams) {
|
||||
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
|
||||
|
||||
auto callee_voice_send = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_voice_receive = callee->media_engine()->GetVoiceChannel(1);
|
||||
auto callee_video_send = callee->media_engine()->GetVideoChannel(0);
|
||||
auto callee_video_receive = callee->media_engine()->GetVideoChannel(1);
|
||||
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());
|
||||
@ -481,10 +489,10 @@ TEST_P(PeerConnectionMediaTest, NewStreamInRemoteOfferAddsRecvStreams) {
|
||||
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get()));
|
||||
|
||||
auto a1 = callee->media_engine()->GetVoiceChannel(1);
|
||||
auto a2 = callee->media_engine()->GetVoiceChannel(3);
|
||||
auto v1 = callee->media_engine()->GetVideoChannel(1);
|
||||
auto v2 = callee->media_engine()->GetVideoChannel(3);
|
||||
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()) {
|
||||
ASSERT_TRUE(a1);
|
||||
EXPECT_EQ(1u, a1->recv_streams().size());
|
||||
@ -527,9 +535,9 @@ TEST_P(PeerConnectionMediaTest, NewStreamInLocalAnswerAddsSendStreams) {
|
||||
ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get(), offer_options,
|
||||
answer_options));
|
||||
|
||||
auto callee_voice = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_voice = callee->media_engine()->GetVoiceSendChannel(0);
|
||||
ASSERT_TRUE(callee_voice);
|
||||
auto callee_video = callee->media_engine()->GetVideoChannel(0);
|
||||
auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
|
||||
ASSERT_TRUE(callee_video);
|
||||
|
||||
if (IsUnifiedPlan()) {
|
||||
@ -1102,12 +1110,12 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithAudioOnlyAnswer) {
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(
|
||||
callee->CreateAnswerAndSetAsLocal(options_reject_video)));
|
||||
|
||||
auto caller_voice_send = caller->media_engine()->GetVoiceChannel(0);
|
||||
auto caller_voice_receive = caller->media_engine()->GetVoiceChannel(1);
|
||||
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()->GetVideoChannel(0);
|
||||
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
|
||||
@ -1118,13 +1126,13 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithAudioOnlyAnswer) {
|
||||
ASSERT_TRUE(
|
||||
caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal()));
|
||||
|
||||
auto callee_voice_send = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_voice_receive = callee->media_engine()->GetVoiceChannel(1);
|
||||
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()->GetVideoChannel(0);
|
||||
auto callee_video_receive = callee->media_engine()->GetVideoChannel(1);
|
||||
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());
|
||||
@ -1135,12 +1143,12 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithAudioOnlyAnswer) {
|
||||
ASSERT_TRUE(
|
||||
callee->SetLocalDescription(callee->CreateAnswer(options_reject_video)));
|
||||
|
||||
callee_voice_send = callee->media_engine()->GetVoiceChannel(0);
|
||||
callee_voice_receive = callee->media_engine()->GetVoiceChannel(1);
|
||||
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()->GetVideoChannel(0);
|
||||
auto callee_video = callee->media_engine()->GetVideoSendChannel(0);
|
||||
EXPECT_FALSE(callee_video);
|
||||
}
|
||||
|
||||
@ -1176,12 +1184,13 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithVideoOnlyAnswer) {
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(
|
||||
callee->CreateAnswerAndSetAsLocal(options_reject_audio)));
|
||||
|
||||
auto caller_voice = caller->media_engine()->GetVoiceChannel(0);
|
||||
auto caller_voice = caller->media_engine()->GetVoiceSendChannel(0);
|
||||
EXPECT_FALSE(caller_voice);
|
||||
auto caller_video = caller->media_engine()->GetVideoChannel(0);
|
||||
ASSERT_TRUE(caller_video);
|
||||
EXPECT_EQ(0u, caller_video->recv_streams().size());
|
||||
EXPECT_EQ(1u, caller_video->send_streams().size());
|
||||
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.
|
||||
@ -1191,13 +1200,13 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithVideoOnlyAnswer) {
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(
|
||||
callee->CreateAnswerAndSetAsLocal(options_no_bundle)));
|
||||
|
||||
auto callee_voice_send = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_voice_receive = callee->media_engine()->GetVoiceChannel(1);
|
||||
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()->GetVideoChannel(0);
|
||||
auto callee_video_receive = callee->media_engine()->GetVideoChannel(1);
|
||||
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());
|
||||
@ -1208,10 +1217,10 @@ TEST_P(PeerConnectionMediaTest, TestAVOfferWithVideoOnlyAnswer) {
|
||||
ASSERT_TRUE(
|
||||
callee->SetLocalDescription(callee->CreateAnswer(options_reject_audio)));
|
||||
|
||||
auto callee_voice = callee->media_engine()->GetVoiceChannel(0);
|
||||
auto callee_voice = callee->media_engine()->GetVoiceReceiveChannel(0);
|
||||
EXPECT_FALSE(callee_voice);
|
||||
callee_video_send = callee->media_engine()->GetVideoChannel(0);
|
||||
callee_video_receive = callee->media_engine()->GetVideoChannel(1);
|
||||
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());
|
||||
@ -1226,7 +1235,7 @@ TEST_P(PeerConnectionMediaTest, MediaEngineErrorPropagatedToClients) {
|
||||
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
|
||||
|
||||
auto video_channel = caller->media_engine()->GetVideoChannel(0);
|
||||
auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
|
||||
video_channel->set_fail_set_send_codecs(true);
|
||||
|
||||
std::string error;
|
||||
@ -1249,7 +1258,7 @@ TEST_P(PeerConnectionMediaTest,
|
||||
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
|
||||
|
||||
auto video_channel = caller->media_engine()->GetVideoChannel(0);
|
||||
auto video_channel = caller->media_engine()->GetVideoSendChannel(0);
|
||||
video_channel->set_fail_set_send_codecs(true);
|
||||
|
||||
EXPECT_FALSE(
|
||||
@ -1347,7 +1356,7 @@ TEST_P(PeerConnectionMediaTest,
|
||||
|
||||
ASSERT_TRUE(caller->SetLocalDescription(caller->CreateOffer()));
|
||||
|
||||
auto caller_voice = caller->media_engine()->GetVoiceChannel(0);
|
||||
auto caller_voice = caller->media_engine()->GetVoiceSendChannel(0);
|
||||
ASSERT_TRUE(caller_voice);
|
||||
const cricket::AudioOptions& audio_options = caller_voice->options();
|
||||
EXPECT_EQ(config.combined_audio_video_bwe,
|
||||
|
||||
@ -119,45 +119,60 @@ class RtpSenderReceiverTest
|
||||
// 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::kBoth, &fake_call_, cricket::MediaConfig(),
|
||||
cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
|
||||
cricket::AudioOptions(), webrtc::CryptoOptions(),
|
||||
webrtc::AudioCodecPairId::Create());
|
||||
media_engine_->video().CreateMediaChannel(
|
||||
cricket::MediaChannel::Role::kBoth, &fake_call_, cricket::MediaConfig(),
|
||||
cricket::MediaChannel::Role::kSend, &fake_call_, cricket::MediaConfig(),
|
||||
cricket::VideoOptions(), webrtc::CryptoOptions(),
|
||||
video_bitrate_allocator_factory_.get());
|
||||
// TODO(hta): Split into sender and receiver channels
|
||||
media_engine_->voice().CreateMediaChannel(
|
||||
cricket::MediaChannel::Role::kReceive, &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(),
|
||||
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
|
||||
|
||||
voice_media_channel_ = absl::WrapUnique(media_engine_->GetVoiceChannel(0));
|
||||
video_media_channel_ = absl::WrapUnique(media_engine_->GetVideoChannel(0));
|
||||
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_channel());
|
||||
RTC_CHECK(video_media_channel());
|
||||
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_ =
|
||||
std::make_unique<cricket::VoiceMediaSendChannel>(voice_media_channel());
|
||||
video_send_channel_ =
|
||||
std::make_unique<cricket::VideoMediaSendChannel>(video_media_channel());
|
||||
voice_send_channel_ = std::make_unique<cricket::VoiceMediaSendChannel>(
|
||||
voice_media_send_channel());
|
||||
video_send_channel_ = std::make_unique<cricket::VideoMediaSendChannel>(
|
||||
video_media_send_channel());
|
||||
|
||||
// Create streams for predefined SSRCs. Streams need to exist in order
|
||||
// for the senders and receievers to apply parameters to them.
|
||||
// Normally these would be created by SetLocalDescription and
|
||||
// SetRemoteDescription.
|
||||
voice_media_channel_->AddSendStream(
|
||||
voice_media_send_channel_->AddSendStream(
|
||||
cricket::StreamParams::CreateLegacy(kAudioSsrc));
|
||||
voice_media_channel_->AddRecvStream(
|
||||
voice_media_receive_channel_->AddRecvStream(
|
||||
cricket::StreamParams::CreateLegacy(kAudioSsrc));
|
||||
voice_media_channel_->AddSendStream(
|
||||
voice_media_send_channel_->AddSendStream(
|
||||
cricket::StreamParams::CreateLegacy(kAudioSsrc2));
|
||||
voice_media_channel_->AddRecvStream(
|
||||
voice_media_receive_channel_->AddRecvStream(
|
||||
cricket::StreamParams::CreateLegacy(kAudioSsrc2));
|
||||
video_media_channel_->AddSendStream(
|
||||
video_media_send_channel_->AddSendStream(
|
||||
cricket::StreamParams::CreateLegacy(kVideoSsrc));
|
||||
video_media_channel_->AddRecvStream(
|
||||
video_media_receive_channel_->AddRecvStream(
|
||||
cricket::StreamParams::CreateLegacy(kVideoSsrc));
|
||||
video_media_channel_->AddSendStream(
|
||||
video_media_send_channel_->AddSendStream(
|
||||
cricket::StreamParams::CreateLegacy(kVideoSsrc2));
|
||||
video_media_channel_->AddRecvStream(
|
||||
video_media_receive_channel_->AddRecvStream(
|
||||
cricket::StreamParams::CreateLegacy(kVideoSsrc2));
|
||||
}
|
||||
|
||||
@ -185,7 +200,7 @@ class RtpSenderReceiverTest
|
||||
const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
|
||||
0, 1);
|
||||
params.codecs.push_back(kTelephoneEventCodec);
|
||||
voice_media_channel()->SetSendParameters(params);
|
||||
voice_media_send_channel()->SetSendParameters(params);
|
||||
}
|
||||
|
||||
void AddVideoTrack() { AddVideoTrack(false); }
|
||||
@ -221,7 +236,7 @@ class RtpSenderReceiverTest
|
||||
audio_rtp_sender_ =
|
||||
AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
|
||||
audio_rtp_sender_->SetMediaChannel(
|
||||
voice_media_channel()->AsVoiceSendChannel());
|
||||
voice_media_send_channel()->AsVoiceSendChannel());
|
||||
}
|
||||
|
||||
void CreateVideoRtpSender(uint32_t ssrc) {
|
||||
@ -240,7 +255,7 @@ class RtpSenderReceiverTest
|
||||
}
|
||||
|
||||
uint32_t CreateVideoRtpSender(const cricket::StreamParams& stream_params) {
|
||||
video_media_channel_->AddSendStream(stream_params);
|
||||
video_media_send_channel_->AddSendStream(stream_params);
|
||||
uint32_t primary_ssrc = stream_params.first_ssrc();
|
||||
CreateVideoRtpSender(primary_ssrc);
|
||||
return primary_ssrc;
|
||||
@ -274,7 +289,7 @@ class RtpSenderReceiverTest
|
||||
EXPECT_CALL(*set_streams_observer, OnSetStreams());
|
||||
video_rtp_sender_->SetStreams({local_stream_->id()});
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
video_rtp_sender_->SetSsrc(ssrc);
|
||||
VerifyVideoChannelInput(ssrc);
|
||||
}
|
||||
@ -282,7 +297,7 @@ class RtpSenderReceiverTest
|
||||
video_rtp_sender_ =
|
||||
VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
}
|
||||
|
||||
void DestroyAudioRtpSender() {
|
||||
@ -301,7 +316,7 @@ class RtpSenderReceiverTest
|
||||
rtc::Thread::Current(), kAudioTrackId, streams,
|
||||
/*is_unified_plan=*/true);
|
||||
audio_rtp_receiver_->SetMediaChannel(
|
||||
voice_media_channel()->AsVoiceReceiveChannel());
|
||||
voice_media_receive_channel()->AsVoiceReceiveChannel());
|
||||
audio_rtp_receiver_->SetupMediaChannel(kAudioSsrc);
|
||||
audio_track_ = audio_rtp_receiver_->audio_track();
|
||||
VerifyVoiceChannelOutput();
|
||||
@ -312,7 +327,7 @@ class RtpSenderReceiverTest
|
||||
video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
|
||||
rtc::Thread::Current(), kVideoTrackId, streams);
|
||||
video_rtp_receiver_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoReceiveChannel());
|
||||
video_media_receive_channel()->AsVideoReceiveChannel());
|
||||
video_rtp_receiver_->SetupMediaChannel(kVideoSsrc);
|
||||
video_track_ = video_rtp_receiver_->video_track();
|
||||
VerifyVideoChannelOutput();
|
||||
@ -327,13 +342,13 @@ class RtpSenderReceiverTest
|
||||
ssrcs.push_back(kVideoSsrcSimulcast + i);
|
||||
cricket::StreamParams stream_params =
|
||||
cricket::CreateSimStreamParams("cname", ssrcs);
|
||||
video_media_channel_->AddRecvStream(stream_params);
|
||||
video_media_receive_channel_->AddRecvStream(stream_params);
|
||||
uint32_t primary_ssrc = stream_params.first_ssrc();
|
||||
|
||||
video_rtp_receiver_ = rtc::make_ref_counted<VideoRtpReceiver>(
|
||||
rtc::Thread::Current(), kVideoTrackId, streams);
|
||||
video_rtp_receiver_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoReceiveChannel());
|
||||
video_media_receive_channel()->AsVideoReceiveChannel());
|
||||
video_rtp_receiver_->SetupMediaChannel(primary_ssrc);
|
||||
video_track_ = video_rtp_receiver_->video_track();
|
||||
}
|
||||
@ -360,53 +375,55 @@ class RtpSenderReceiverTest
|
||||
void VerifyVoiceChannelInput(uint32_t ssrc) {
|
||||
// Verify that the media channel has an audio source, and the stream isn't
|
||||
// muted.
|
||||
EXPECT_TRUE(voice_media_channel()->HasSource(ssrc));
|
||||
EXPECT_FALSE(voice_media_channel()->IsStreamMuted(ssrc));
|
||||
EXPECT_TRUE(voice_media_send_channel()->HasSource(ssrc));
|
||||
EXPECT_FALSE(voice_media_send_channel()->IsStreamMuted(ssrc));
|
||||
}
|
||||
|
||||
void VerifyVideoChannelInput() { VerifyVideoChannelInput(kVideoSsrc); }
|
||||
|
||||
void VerifyVideoChannelInput(uint32_t ssrc) {
|
||||
// Verify that the media channel has a video source,
|
||||
EXPECT_TRUE(video_media_channel_->HasSource(ssrc));
|
||||
EXPECT_TRUE(video_media_send_channel_->HasSource(ssrc));
|
||||
}
|
||||
|
||||
void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); }
|
||||
|
||||
void VerifyVoiceChannelNoInput(uint32_t ssrc) {
|
||||
// Verify that the media channel's source is reset.
|
||||
EXPECT_FALSE(voice_media_channel()->HasSource(ssrc));
|
||||
EXPECT_FALSE(voice_media_receive_channel()->HasSource(ssrc));
|
||||
}
|
||||
|
||||
void VerifyVideoChannelNoInput() { VerifyVideoChannelNoInput(kVideoSsrc); }
|
||||
|
||||
void VerifyVideoChannelNoInput(uint32_t ssrc) {
|
||||
// Verify that the media channel's source is reset.
|
||||
EXPECT_FALSE(video_media_channel_->HasSource(ssrc));
|
||||
EXPECT_FALSE(video_media_receive_channel_->HasSource(ssrc));
|
||||
}
|
||||
|
||||
void VerifyVoiceChannelOutput() {
|
||||
// Verify that the volume is initialized to 1.
|
||||
double volume;
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(1, volume);
|
||||
}
|
||||
|
||||
void VerifyVideoChannelOutput() {
|
||||
// Verify that the media channel has a sink.
|
||||
EXPECT_TRUE(video_media_channel_->HasSink(kVideoSsrc));
|
||||
EXPECT_TRUE(video_media_receive_channel_->HasSink(kVideoSsrc));
|
||||
}
|
||||
|
||||
void VerifyVoiceChannelNoOutput() {
|
||||
// Verify that the volume is reset to 0.
|
||||
double volume;
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0, volume);
|
||||
}
|
||||
|
||||
void VerifyVideoChannelNoOutput() {
|
||||
// Verify that the media channel's sink is reset.
|
||||
EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc));
|
||||
EXPECT_FALSE(video_media_receive_channel_->HasSink(kVideoSsrc));
|
||||
}
|
||||
|
||||
// Verifies that the encoding layers contain the specified RIDs.
|
||||
@ -483,7 +500,8 @@ class RtpSenderReceiverTest
|
||||
RunDisableEncodingLayersTest(all_layers, disabled_layers,
|
||||
video_rtp_sender_.get());
|
||||
|
||||
auto channel_parameters = video_media_channel_->GetRtpSendParameters(ssrc);
|
||||
auto channel_parameters =
|
||||
video_media_send_channel_->GetRtpSendParameters(ssrc);
|
||||
ASSERT_EQ(channel_parameters.encodings.size(), all_layers.size());
|
||||
for (size_t i = 0; i < all_layers.size(); ++i) {
|
||||
EXPECT_EQ(all_layers[i], channel_parameters.encodings[i].rid);
|
||||
@ -506,11 +524,17 @@ class RtpSenderReceiverTest
|
||||
}
|
||||
|
||||
protected:
|
||||
cricket::FakeVideoMediaChannel* video_media_channel() {
|
||||
return video_media_channel_.get();
|
||||
cricket::FakeVideoMediaChannel* video_media_send_channel() {
|
||||
return video_media_send_channel_.get();
|
||||
}
|
||||
cricket::FakeVoiceMediaChannel* voice_media_channel() {
|
||||
return voice_media_channel_.get();
|
||||
cricket::FakeVoiceMediaChannel* voice_media_send_channel() {
|
||||
return voice_media_send_channel_.get();
|
||||
}
|
||||
cricket::FakeVideoMediaChannel* video_media_receive_channel() {
|
||||
return video_media_receive_channel_.get();
|
||||
}
|
||||
cricket::FakeVoiceMediaChannel* voice_media_receive_channel() {
|
||||
return voice_media_receive_channel_.get();
|
||||
}
|
||||
|
||||
test::RunLoop run_loop_;
|
||||
@ -526,8 +550,10 @@ class RtpSenderReceiverTest
|
||||
std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
|
||||
rtc::UniqueRandomIdGenerator ssrc_generator_;
|
||||
cricket::FakeCall fake_call_;
|
||||
std::unique_ptr<cricket::FakeVoiceMediaChannel> voice_media_channel_;
|
||||
std::unique_ptr<cricket::FakeVideoMediaChannel> video_media_channel_;
|
||||
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_;
|
||||
std::unique_ptr<cricket::VoiceMediaSendChannel> voice_send_channel_;
|
||||
std::unique_ptr<cricket::VideoMediaSendChannel> video_send_channel_;
|
||||
rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
|
||||
@ -585,7 +611,7 @@ TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) {
|
||||
auto source = LocalAudioSource::Create(&options);
|
||||
CreateAudioRtpSender(source);
|
||||
|
||||
EXPECT_EQ(true, voice_media_channel()->options().echo_cancellation);
|
||||
EXPECT_EQ(true, voice_media_send_channel()->options().echo_cancellation);
|
||||
|
||||
DestroyAudioRtpSender();
|
||||
}
|
||||
@ -596,10 +622,10 @@ TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) {
|
||||
CreateAudioRtpSender();
|
||||
|
||||
audio_track_->set_enabled(false);
|
||||
EXPECT_TRUE(voice_media_channel()->IsStreamMuted(kAudioSsrc));
|
||||
EXPECT_TRUE(voice_media_send_channel()->IsStreamMuted(kAudioSsrc));
|
||||
|
||||
audio_track_->set_enabled(true);
|
||||
EXPECT_FALSE(voice_media_channel()->IsStreamMuted(kAudioSsrc));
|
||||
EXPECT_FALSE(voice_media_send_channel()->IsStreamMuted(kAudioSsrc));
|
||||
|
||||
DestroyAudioRtpSender();
|
||||
}
|
||||
@ -610,19 +636,22 @@ TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) {
|
||||
CreateAudioRtpReceiver();
|
||||
|
||||
double volume;
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(1, volume);
|
||||
|
||||
// Handling of enable/disable is applied asynchronously.
|
||||
audio_track_->set_enabled(false);
|
||||
run_loop_.Flush();
|
||||
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0, volume);
|
||||
|
||||
audio_track_->set_enabled(true);
|
||||
run_loop_.Flush();
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(1, volume);
|
||||
|
||||
DestroyAudioRtpReceiver();
|
||||
@ -677,7 +706,8 @@ TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
|
||||
double volume;
|
||||
audio_track_->GetSource()->SetVolume(0.5);
|
||||
run_loop_.Flush();
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0.5, volume);
|
||||
|
||||
// Disable the audio track, this should prevent setting the volume.
|
||||
@ -685,19 +715,22 @@ TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
|
||||
RTC_DCHECK_EQ(worker_thread_, run_loop_.task_queue());
|
||||
run_loop_.Flush();
|
||||
audio_track_->GetSource()->SetVolume(0.8);
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0, volume);
|
||||
|
||||
// When the track is enabled, the previously set volume should take effect.
|
||||
audio_track_->set_enabled(true);
|
||||
run_loop_.Flush();
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0.8, volume);
|
||||
|
||||
// Try changing volume one more time.
|
||||
audio_track_->GetSource()->SetVolume(0.9);
|
||||
run_loop_.Flush();
|
||||
EXPECT_TRUE(voice_media_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_TRUE(
|
||||
voice_media_receive_channel()->GetOutputVolume(kAudioSsrc, &volume));
|
||||
EXPECT_EQ(0.9, volume);
|
||||
|
||||
DestroyAudioRtpReceiver();
|
||||
@ -706,16 +739,16 @@ TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
|
||||
TEST_F(RtpSenderReceiverTest, AudioRtpReceiverDelay) {
|
||||
CreateAudioRtpReceiver();
|
||||
VerifyRtpReceiverDelayBehaviour(
|
||||
voice_media_channel()->AsVoiceReceiveChannel(), audio_rtp_receiver_.get(),
|
||||
kAudioSsrc);
|
||||
voice_media_receive_channel()->AsVoiceReceiveChannel(),
|
||||
audio_rtp_receiver_.get(), kAudioSsrc);
|
||||
DestroyAudioRtpReceiver();
|
||||
}
|
||||
|
||||
TEST_F(RtpSenderReceiverTest, VideoRtpReceiverDelay) {
|
||||
CreateVideoRtpReceiver();
|
||||
VerifyRtpReceiverDelayBehaviour(
|
||||
video_media_channel()->AsVideoReceiveChannel(), video_rtp_receiver_.get(),
|
||||
kVideoSsrc);
|
||||
video_media_receive_channel()->AsVideoReceiveChannel(),
|
||||
video_rtp_receiver_.get(), kVideoSsrc);
|
||||
DestroyVideoRtpReceiver();
|
||||
}
|
||||
|
||||
@ -953,9 +986,9 @@ TEST_F(RtpSenderReceiverTest, AudioSenderInitParametersMovedAfterNegotiation) {
|
||||
std::vector<uint32_t> ssrcs(1, 1);
|
||||
cricket::StreamParams stream_params =
|
||||
cricket::CreateSimStreamParams("cname", ssrcs);
|
||||
voice_media_channel()->AddSendStream(stream_params);
|
||||
voice_media_send_channel()->AddSendStream(stream_params);
|
||||
audio_rtp_sender_->SetMediaChannel(
|
||||
voice_media_channel()->AsVoiceSendChannel());
|
||||
voice_media_send_channel()->AsVoiceSendChannel());
|
||||
audio_rtp_sender_->SetSsrc(1);
|
||||
|
||||
params = audio_rtp_sender_->GetParameters();
|
||||
@ -1070,7 +1103,7 @@ TEST_F(RtpSenderReceiverTest, AudioSenderCantSetUnimplementedRtpParameters) {
|
||||
TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
|
||||
CreateAudioRtpSender();
|
||||
|
||||
EXPECT_EQ(-1, voice_media_channel()->max_bps());
|
||||
EXPECT_EQ(-1, voice_media_send_channel()->max_bps());
|
||||
webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
|
||||
@ -1083,12 +1116,12 @@ TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
|
||||
EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
|
||||
|
||||
// Verify that the audio channel received the new parameters.
|
||||
params = voice_media_channel()->GetRtpSendParameters(kAudioSsrc);
|
||||
params = voice_media_send_channel()->GetRtpSendParameters(kAudioSsrc);
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
|
||||
|
||||
// Verify that the global bitrate limit has not been changed.
|
||||
EXPECT_EQ(-1, voice_media_channel()->max_bps());
|
||||
EXPECT_EQ(-1, voice_media_send_channel()->max_bps());
|
||||
|
||||
DestroyAudioRtpSender();
|
||||
}
|
||||
@ -1108,7 +1141,7 @@ TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) {
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
|
||||
|
||||
params = voice_media_channel()->GetRtpSendParameters(kAudioSsrc);
|
||||
params = voice_media_send_channel()->GetRtpSendParameters(kAudioSsrc);
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
|
||||
|
||||
@ -1207,9 +1240,9 @@ TEST_F(RtpSenderReceiverTest, VideoSenderInitParametersMovedAfterNegotiation) {
|
||||
ssrcs.push_back(kVideoSsrcSimulcast + i);
|
||||
cricket::StreamParams stream_params =
|
||||
cricket::CreateSimStreamParams("cname", ssrcs);
|
||||
video_media_channel()->AddSendStream(stream_params);
|
||||
video_media_send_channel()->AddSendStream(stream_params);
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
video_rtp_sender_->SetSsrc(kVideoSsrcSimulcast);
|
||||
|
||||
params = video_rtp_sender_->GetParameters();
|
||||
@ -1248,9 +1281,9 @@ TEST_F(RtpSenderReceiverTest,
|
||||
ssrcs.push_back(kVideoSsrcSimulcast + i);
|
||||
cricket::StreamParams stream_params =
|
||||
cricket::CreateSimStreamParams("cname", ssrcs);
|
||||
video_media_channel()->AddSendStream(stream_params);
|
||||
video_media_send_channel()->AddSendStream(stream_params);
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
video_rtp_sender_->SetSsrc(kVideoSsrcSimulcast);
|
||||
|
||||
params = video_rtp_sender_->GetParameters();
|
||||
@ -1292,9 +1325,9 @@ TEST_F(RtpSenderReceiverDeathTest,
|
||||
ssrcs.push_back(kVideoSsrcSimulcast + i);
|
||||
cricket::StreamParams stream_params =
|
||||
cricket::StreamParams::CreateLegacy(kVideoSsrc);
|
||||
video_media_channel()->AddSendStream(stream_params);
|
||||
video_media_send_channel()->AddSendStream(stream_params);
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
EXPECT_DEATH(video_rtp_sender_->SetSsrc(kVideoSsrcSimulcast), "");
|
||||
}
|
||||
#endif
|
||||
@ -1525,7 +1558,7 @@ TEST_F(RtpSenderReceiverTest, VideoSenderCantSetReadOnlyEncodingParameters) {
|
||||
TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrate) {
|
||||
CreateVideoRtpSender();
|
||||
|
||||
EXPECT_EQ(-1, video_media_channel()->max_bps());
|
||||
EXPECT_EQ(-1, video_media_send_channel()->max_bps());
|
||||
webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_FALSE(params.encodings[0].min_bitrate_bps);
|
||||
@ -1541,13 +1574,13 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrate) {
|
||||
EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
|
||||
|
||||
// Verify that the video channel received the new parameters.
|
||||
params = video_media_channel()->GetRtpSendParameters(kVideoSsrc);
|
||||
params = video_media_send_channel()->GetRtpSendParameters(kVideoSsrc);
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(100, params.encodings[0].min_bitrate_bps);
|
||||
EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
|
||||
|
||||
// Verify that the global bitrate limit has not been changed.
|
||||
EXPECT_EQ(-1, video_media_channel()->max_bps());
|
||||
EXPECT_EQ(-1, video_media_send_channel()->max_bps());
|
||||
|
||||
DestroyVideoRtpSender();
|
||||
}
|
||||
@ -1565,7 +1598,8 @@ TEST_F(RtpSenderReceiverTest, SetVideoMinMaxSendBitrateSimulcast) {
|
||||
EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok());
|
||||
|
||||
// Verify that the video channel received the new parameters.
|
||||
params = video_media_channel()->GetRtpSendParameters(kVideoSsrcSimulcast);
|
||||
params =
|
||||
video_media_send_channel()->GetRtpSendParameters(kVideoSsrcSimulcast);
|
||||
EXPECT_EQ(kVideoSimulcastLayerCount, params.encodings.size());
|
||||
EXPECT_EQ(100, params.encodings[0].min_bitrate_bps);
|
||||
EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
|
||||
@ -1590,7 +1624,7 @@ TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) {
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
|
||||
|
||||
params = video_media_channel()->GetRtpSendParameters(kVideoSsrc);
|
||||
params = video_media_send_channel()->GetRtpSendParameters(kVideoSsrc);
|
||||
EXPECT_EQ(1U, params.encodings.size());
|
||||
EXPECT_EQ(new_bitrate_priority, params.encodings[0].bitrate_priority);
|
||||
|
||||
@ -1644,23 +1678,23 @@ TEST_F(RtpSenderReceiverTest, PropagatesVideoTrackContentHint) {
|
||||
video_track_->set_enabled(true);
|
||||
|
||||
// `video_track_` is not screencast by default.
|
||||
EXPECT_EQ(false, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(false, video_media_send_channel()->options().is_screencast);
|
||||
// No content hint should be set by default.
|
||||
EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
|
||||
video_track_->content_hint());
|
||||
// Setting detailed should turn a non-screencast source into screencast mode.
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
// Removing the content hint should turn the track back into non-screencast
|
||||
// mode.
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
|
||||
EXPECT_EQ(false, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(false, video_media_send_channel()->options().is_screencast);
|
||||
// Setting fluid should remain in non-screencast mode (its default).
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
|
||||
EXPECT_EQ(false, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(false, video_media_send_channel()->options().is_screencast);
|
||||
// Setting text should have the same effect as Detailed
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kText);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
|
||||
DestroyVideoRtpSender();
|
||||
}
|
||||
@ -1674,22 +1708,22 @@ TEST_F(RtpSenderReceiverTest,
|
||||
video_track_->set_enabled(true);
|
||||
|
||||
// `video_track_` with a screencast source should be screencast by default.
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
// No content hint should be set by default.
|
||||
EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
|
||||
video_track_->content_hint());
|
||||
// Setting fluid should turn a screencast source into non-screencast mode.
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
|
||||
EXPECT_EQ(false, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(false, video_media_send_channel()->options().is_screencast);
|
||||
// Removing the content hint should turn the track back into screencast mode.
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
// Setting detailed should still remain in screencast mode (its default).
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
// Setting text should have the same effect as Detailed
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kText);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
|
||||
DestroyVideoRtpSender();
|
||||
}
|
||||
@ -1710,21 +1744,21 @@ TEST_F(RtpSenderReceiverTest,
|
||||
EXPECT_CALL(*set_streams_observer, OnSetStreams());
|
||||
video_rtp_sender_->SetStreams({local_stream_->id()});
|
||||
video_rtp_sender_->SetMediaChannel(
|
||||
video_media_channel()->AsVideoSendChannel());
|
||||
video_media_send_channel()->AsVideoSendChannel());
|
||||
video_track_->set_enabled(true);
|
||||
|
||||
// Sender is not ready to send (no SSRC) so no option should have been set.
|
||||
EXPECT_EQ(absl::nullopt, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(absl::nullopt, video_media_send_channel()->options().is_screencast);
|
||||
|
||||
// Verify that the content hint is accounted for when video_rtp_sender_ does
|
||||
// get enabled.
|
||||
video_rtp_sender_->SetSsrc(kVideoSsrc);
|
||||
EXPECT_EQ(true, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(true, video_media_send_channel()->options().is_screencast);
|
||||
|
||||
// And removing the hint should go back to false (to verify that false was
|
||||
// default correctly).
|
||||
video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
|
||||
EXPECT_EQ(false, video_media_channel()->options().is_screencast);
|
||||
EXPECT_EQ(false, video_media_send_channel()->options().is_screencast);
|
||||
|
||||
DestroyVideoRtpSender();
|
||||
}
|
||||
@ -1763,22 +1797,22 @@ TEST_F(RtpSenderReceiverTest, InsertDtmf) {
|
||||
auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
|
||||
ASSERT_NE(nullptr, dtmf_sender);
|
||||
|
||||
EXPECT_EQ(0U, voice_media_channel()->dtmf_info_queue().size());
|
||||
EXPECT_EQ(0U, voice_media_send_channel()->dtmf_info_queue().size());
|
||||
|
||||
// Insert DTMF
|
||||
const int expected_duration = 90;
|
||||
dtmf_sender->InsertDtmf("012", expected_duration, 100);
|
||||
|
||||
// Verify
|
||||
ASSERT_EQ_WAIT(3U, voice_media_channel()->dtmf_info_queue().size(),
|
||||
ASSERT_EQ_WAIT(3U, voice_media_send_channel()->dtmf_info_queue().size(),
|
||||
kDefaultTimeout);
|
||||
const uint32_t send_ssrc =
|
||||
voice_media_channel()->send_streams()[0].first_ssrc();
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_channel()->dtmf_info_queue()[0],
|
||||
voice_media_send_channel()->send_streams()[0].first_ssrc();
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_send_channel()->dtmf_info_queue()[0],
|
||||
send_ssrc, 0, expected_duration));
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_channel()->dtmf_info_queue()[1],
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_send_channel()->dtmf_info_queue()[1],
|
||||
send_ssrc, 1, expected_duration));
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_channel()->dtmf_info_queue()[2],
|
||||
EXPECT_TRUE(CompareDtmfInfo(voice_media_send_channel()->dtmf_info_queue()[2],
|
||||
send_ssrc, 2, expected_duration));
|
||||
}
|
||||
|
||||
|
||||
@ -28,8 +28,9 @@ using ::testing::Mock;
|
||||
namespace cricket {
|
||||
class MockVoiceMediaChannel : public VoiceMediaChannel {
|
||||
public:
|
||||
explicit MockVoiceMediaChannel(webrtc::TaskQueueBase* network_thread)
|
||||
: VoiceMediaChannel(MediaChannel::Role::kBoth, network_thread) {}
|
||||
MockVoiceMediaChannel(MediaChannel::Role role,
|
||||
webrtc::TaskQueueBase* network_thread)
|
||||
: VoiceMediaChannel(role, network_thread) {}
|
||||
|
||||
MOCK_METHOD(void,
|
||||
SetInterface,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user