blob: f5b06d11cb21005928b3bf5f5f652e103d6f8757 [file] [log] [blame]
deadbeef70ab1a12015-09-28 16:53:55 -07001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2012 The WebRTC project authors. All Rights Reserved.
deadbeef70ab1a12015-09-28 16:53:55 -07003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
deadbeef70ab1a12015-09-28 16:53:55 -07009 */
10
kwibergd1fe2812016-04-27 06:47:29 -070011#include <memory>
deadbeef70ab1a12015-09-28 16:53:55 -070012#include <string>
Tommif888bb52015-12-12 01:37:01 +010013#include <utility>
deadbeef70ab1a12015-09-28 16:53:55 -070014
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020015#include "media/base/fakemediaengine.h"
Steve Antonc9e15602017-11-06 15:40:09 -080016#include "media/base/rtpdataengine.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020017#include "media/engine/fakewebrtccall.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020018#include "pc/audiotrack.h"
19#include "pc/channelmanager.h"
20#include "pc/localaudiosource.h"
21#include "pc/mediastream.h"
22#include "pc/remoteaudiosource.h"
23#include "pc/rtpreceiver.h"
24#include "pc/rtpsender.h"
25#include "pc/streamcollection.h"
Zhi Huangb5261582017-09-29 10:51:43 -070026#include "pc/test/faketransportcontroller.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020027#include "pc/test/fakevideotracksource.h"
28#include "pc/videotrack.h"
29#include "pc/videotracksource.h"
30#include "rtc_base/gunit.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020031#include "test/gmock.h"
32#include "test/gtest.h"
deadbeef70ab1a12015-09-28 16:53:55 -070033
34using ::testing::_;
35using ::testing::Exactly;
deadbeef5dd42fd2016-05-02 16:20:01 -070036using ::testing::InvokeWithoutArgs;
skvladdc1c62c2016-03-16 19:07:43 -070037using ::testing::Return;
deadbeef70ab1a12015-09-28 16:53:55 -070038
deadbeef20cb0c12017-02-01 20:27:00 -080039namespace {
40
deadbeef70ab1a12015-09-28 16:53:55 -070041static const char kStreamLabel1[] = "local_stream_1";
42static const char kVideoTrackId[] = "video_1";
43static const char kAudioTrackId[] = "audio_1";
Peter Boström0c4e06b2015-10-07 12:23:21 +020044static const uint32_t kVideoSsrc = 98;
deadbeeffac06552015-11-25 11:26:01 -080045static const uint32_t kVideoSsrc2 = 100;
Peter Boström0c4e06b2015-10-07 12:23:21 +020046static const uint32_t kAudioSsrc = 99;
deadbeeffac06552015-11-25 11:26:01 -080047static const uint32_t kAudioSsrc2 = 101;
deadbeef20cb0c12017-02-01 20:27:00 -080048static const int kDefaultTimeout = 10000; // 10 seconds.
deadbeef20cb0c12017-02-01 20:27:00 -080049} // namespace
deadbeef70ab1a12015-09-28 16:53:55 -070050
51namespace webrtc {
52
deadbeef20cb0c12017-02-01 20:27:00 -080053class RtpSenderReceiverTest : public testing::Test,
54 public sigslot::has_slots<> {
tkchin3784b4a2016-06-24 19:31:47 -070055 public:
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070056 RtpSenderReceiverTest()
57 : // Create fake media engine/etc. so we can create channels to use to
deadbeefe814a0d2017-02-25 18:15:09 -080058 // test RtpSenders/RtpReceivers.
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070059 media_engine_(new cricket::FakeMediaEngine()),
Steve Antonc9e15602017-11-06 15:40:09 -080060 channel_manager_(rtc::WrapUnique(media_engine_),
61 rtc::MakeUnique<cricket::RtpDataEngine>(),
62 rtc::Thread::Current(),
63 rtc::Thread::Current()),
skvlad11a9cbf2016-10-07 11:53:05 -070064 fake_call_(Call::Config(&event_log_)),
deadbeefe814a0d2017-02-25 18:15:09 -080065 local_stream_(MediaStream::Create(kStreamLabel1)) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070066 // Create channels to be used by the RtpSenders and RtpReceivers.
67 channel_manager_.Init();
deadbeef7af91dd2016-12-13 11:29:11 -080068 bool srtp_required = true;
zhihuangb2cdd932017-01-19 16:54:25 -080069 cricket::DtlsTransportInternal* rtp_transport =
70 fake_transport_controller_.CreateDtlsTransport(
zhihuangf5b251b2017-01-12 19:37:48 -080071 cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070072 voice_channel_ = channel_manager_.CreateVoiceChannel(
nisseeaabdf62017-05-05 02:23:02 -070073 &fake_call_, cricket::MediaConfig(),
74 rtp_transport, nullptr, rtc::Thread::Current(),
deadbeef1a2183d2017-02-10 23:44:49 -080075 cricket::CN_AUDIO, srtp_required, cricket::AudioOptions());
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070076 video_channel_ = channel_manager_.CreateVideoChannel(
nisseeaabdf62017-05-05 02:23:02 -070077 &fake_call_, cricket::MediaConfig(),
78 rtp_transport, nullptr, rtc::Thread::Current(),
deadbeef1a2183d2017-02-10 23:44:49 -080079 cricket::CN_VIDEO, srtp_required, cricket::VideoOptions());
deadbeef20cb0c12017-02-01 20:27:00 -080080 voice_channel_->Enable(true);
81 video_channel_->Enable(true);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -070082 voice_media_channel_ = media_engine_->GetVoiceChannel(0);
83 video_media_channel_ = media_engine_->GetVideoChannel(0);
84 RTC_CHECK(voice_channel_);
85 RTC_CHECK(video_channel_);
86 RTC_CHECK(voice_media_channel_);
87 RTC_CHECK(video_media_channel_);
88
89 // Create streams for predefined SSRCs. Streams need to exist in order
90 // for the senders and receievers to apply parameters to them.
91 // Normally these would be created by SetLocalDescription and
92 // SetRemoteDescription.
93 voice_media_channel_->AddSendStream(
94 cricket::StreamParams::CreateLegacy(kAudioSsrc));
95 voice_media_channel_->AddRecvStream(
96 cricket::StreamParams::CreateLegacy(kAudioSsrc));
97 voice_media_channel_->AddSendStream(
98 cricket::StreamParams::CreateLegacy(kAudioSsrc2));
99 voice_media_channel_->AddRecvStream(
100 cricket::StreamParams::CreateLegacy(kAudioSsrc2));
101 video_media_channel_->AddSendStream(
102 cricket::StreamParams::CreateLegacy(kVideoSsrc));
103 video_media_channel_->AddRecvStream(
104 cricket::StreamParams::CreateLegacy(kVideoSsrc));
105 video_media_channel_->AddSendStream(
106 cricket::StreamParams::CreateLegacy(kVideoSsrc2));
107 video_media_channel_->AddRecvStream(
108 cricket::StreamParams::CreateLegacy(kVideoSsrc2));
tkchin3784b4a2016-06-24 19:31:47 -0700109 }
Taylor Brandstetter2d549172016-06-24 14:18:22 -0700110
deadbeef20cb0c12017-02-01 20:27:00 -0800111 // Needed to use DTMF sender.
112 void AddDtmfCodec() {
113 cricket::AudioSendParameters params;
114 const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
115 0, 1);
116 params.codecs.push_back(kTelephoneEventCodec);
117 voice_media_channel_->SetSendParameters(params);
118 }
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700119
pbos5214a0a2016-12-16 15:39:11 -0800120 void AddVideoTrack() { AddVideoTrack(false); }
121
122 void AddVideoTrack(bool is_screencast) {
perkja3ede6c2016-03-08 01:27:48 +0100123 rtc::scoped_refptr<VideoTrackSourceInterface> source(
pbos5214a0a2016-12-16 15:39:11 -0800124 FakeVideoTrackSource::Create(is_screencast));
perkj773be362017-07-31 23:22:01 -0700125 video_track_ =
126 VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
deadbeefe814a0d2017-02-25 18:15:09 -0800127 EXPECT_TRUE(local_stream_->AddTrack(video_track_));
deadbeef70ab1a12015-09-28 16:53:55 -0700128 }
129
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700130 void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
131
Mirko Bonadeic61ce0d2017-11-21 17:04:20 +0100132 void CreateAudioRtpSender(
133 const rtc::scoped_refptr<LocalAudioSource>& source) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700134 audio_track_ = AudioTrack::Create(kAudioTrackId, source);
deadbeefe814a0d2017-02-25 18:15:09 -0800135 EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
deadbeeffac06552015-11-25 11:26:01 -0800136 audio_rtp_sender_ =
deadbeefe814a0d2017-02-25 18:15:09 -0800137 new AudioRtpSender(local_stream_->GetAudioTracks()[0],
Steve Anton8ffb9c32017-08-31 15:45:38 -0700138 {local_stream_->label()}, voice_channel_, nullptr);
deadbeeffac06552015-11-25 11:26:01 -0800139 audio_rtp_sender_->SetSsrc(kAudioSsrc);
deadbeef20cb0c12017-02-01 20:27:00 -0800140 audio_rtp_sender_->GetOnDestroyedSignal()->connect(
141 this, &RtpSenderReceiverTest::OnAudioSenderDestroyed);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700142 VerifyVoiceChannelInput();
deadbeef70ab1a12015-09-28 16:53:55 -0700143 }
144
deadbeef20cb0c12017-02-01 20:27:00 -0800145 void OnAudioSenderDestroyed() { audio_sender_destroyed_signal_fired_ = true; }
146
pbos5214a0a2016-12-16 15:39:11 -0800147 void CreateVideoRtpSender() { CreateVideoRtpSender(false); }
148
149 void CreateVideoRtpSender(bool is_screencast) {
150 AddVideoTrack(is_screencast);
deadbeefe814a0d2017-02-25 18:15:09 -0800151 video_rtp_sender_ =
152 new VideoRtpSender(local_stream_->GetVideoTracks()[0],
Steve Anton8ffb9c32017-08-31 15:45:38 -0700153 {local_stream_->label()}, video_channel_);
deadbeeffac06552015-11-25 11:26:01 -0800154 video_rtp_sender_->SetSsrc(kVideoSsrc);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700155 VerifyVideoChannelInput();
deadbeef70ab1a12015-09-28 16:53:55 -0700156 }
157
158 void DestroyAudioRtpSender() {
deadbeef70ab1a12015-09-28 16:53:55 -0700159 audio_rtp_sender_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700160 VerifyVoiceChannelNoInput();
deadbeef70ab1a12015-09-28 16:53:55 -0700161 }
162
163 void DestroyVideoRtpSender() {
deadbeef70ab1a12015-09-28 16:53:55 -0700164 video_rtp_sender_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700165 VerifyVideoChannelNoInput();
deadbeef70ab1a12015-09-28 16:53:55 -0700166 }
167
168 void CreateAudioRtpReceiver() {
deadbeefe814a0d2017-02-25 18:15:09 -0800169 audio_rtp_receiver_ =
170 new AudioRtpReceiver(kAudioTrackId, kAudioSsrc, voice_channel_);
perkjd61bf802016-03-24 03:16:19 -0700171 audio_track_ = audio_rtp_receiver_->audio_track();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700172 VerifyVoiceChannelOutput();
deadbeef70ab1a12015-09-28 16:53:55 -0700173 }
174
175 void CreateVideoRtpReceiver() {
deadbeefe814a0d2017-02-25 18:15:09 -0800176 video_rtp_receiver_ = new VideoRtpReceiver(
177 kVideoTrackId, rtc::Thread::Current(), kVideoSsrc, video_channel_);
perkjf0dcfe22016-03-10 18:32:00 +0100178 video_track_ = video_rtp_receiver_->video_track();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700179 VerifyVideoChannelOutput();
deadbeef70ab1a12015-09-28 16:53:55 -0700180 }
181
182 void DestroyAudioRtpReceiver() {
deadbeef70ab1a12015-09-28 16:53:55 -0700183 audio_rtp_receiver_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700184 VerifyVoiceChannelNoOutput();
deadbeef70ab1a12015-09-28 16:53:55 -0700185 }
186
187 void DestroyVideoRtpReceiver() {
deadbeef70ab1a12015-09-28 16:53:55 -0700188 video_rtp_receiver_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700189 VerifyVideoChannelNoOutput();
190 }
191
192 void VerifyVoiceChannelInput() { VerifyVoiceChannelInput(kAudioSsrc); }
193
194 void VerifyVoiceChannelInput(uint32_t ssrc) {
195 // Verify that the media channel has an audio source, and the stream isn't
196 // muted.
197 EXPECT_TRUE(voice_media_channel_->HasSource(ssrc));
198 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(ssrc));
199 }
200
201 void VerifyVideoChannelInput() { VerifyVideoChannelInput(kVideoSsrc); }
202
203 void VerifyVideoChannelInput(uint32_t ssrc) {
204 // Verify that the media channel has a video source,
205 EXPECT_TRUE(video_media_channel_->HasSource(ssrc));
206 }
207
208 void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); }
209
210 void VerifyVoiceChannelNoInput(uint32_t ssrc) {
211 // Verify that the media channel's source is reset.
212 EXPECT_FALSE(voice_media_channel_->HasSource(ssrc));
213 }
214
215 void VerifyVideoChannelNoInput() { VerifyVideoChannelNoInput(kVideoSsrc); }
216
217 void VerifyVideoChannelNoInput(uint32_t ssrc) {
218 // Verify that the media channel's source is reset.
219 EXPECT_FALSE(video_media_channel_->HasSource(ssrc));
220 }
221
222 void VerifyVoiceChannelOutput() {
223 // Verify that the volume is initialized to 1.
224 double volume;
225 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
226 EXPECT_EQ(1, volume);
227 }
228
229 void VerifyVideoChannelOutput() {
230 // Verify that the media channel has a sink.
231 EXPECT_TRUE(video_media_channel_->HasSink(kVideoSsrc));
232 }
233
234 void VerifyVoiceChannelNoOutput() {
235 // Verify that the volume is reset to 0.
236 double volume;
237 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
238 EXPECT_EQ(0, volume);
239 }
240
241 void VerifyVideoChannelNoOutput() {
242 // Verify that the media channel's sink is reset.
243 EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc));
deadbeef70ab1a12015-09-28 16:53:55 -0700244 }
245
246 protected:
skvlad11a9cbf2016-10-07 11:53:05 -0700247 webrtc::RtcEventLogNullImpl event_log_;
deadbeef112b2e92017-02-10 20:13:37 -0800248 // |media_engine_| is actually owned by |channel_manager_|.
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700249 cricket::FakeMediaEngine* media_engine_;
250 cricket::FakeTransportController fake_transport_controller_;
251 cricket::ChannelManager channel_manager_;
252 cricket::FakeCall fake_call_;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700253 cricket::VoiceChannel* voice_channel_;
254 cricket::VideoChannel* video_channel_;
255 cricket::FakeVoiceMediaChannel* voice_media_channel_;
256 cricket::FakeVideoMediaChannel* video_media_channel_;
deadbeef70ab1a12015-09-28 16:53:55 -0700257 rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
258 rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
259 rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
260 rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
deadbeefe814a0d2017-02-25 18:15:09 -0800261 rtc::scoped_refptr<MediaStreamInterface> local_stream_;
deadbeef70ab1a12015-09-28 16:53:55 -0700262 rtc::scoped_refptr<VideoTrackInterface> video_track_;
263 rtc::scoped_refptr<AudioTrackInterface> audio_track_;
deadbeef20cb0c12017-02-01 20:27:00 -0800264 bool audio_sender_destroyed_signal_fired_ = false;
deadbeef70ab1a12015-09-28 16:53:55 -0700265};
266
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700267// Test that |voice_channel_| is updated when an audio track is associated
deadbeef70ab1a12015-09-28 16:53:55 -0700268// and disassociated with an AudioRtpSender.
269TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) {
270 CreateAudioRtpSender();
271 DestroyAudioRtpSender();
272}
273
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700274// Test that |video_channel_| is updated when a video track is associated and
deadbeef70ab1a12015-09-28 16:53:55 -0700275// disassociated with a VideoRtpSender.
276TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) {
277 CreateVideoRtpSender();
278 DestroyVideoRtpSender();
279}
280
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700281// Test that |voice_channel_| is updated when a remote audio track is
deadbeef70ab1a12015-09-28 16:53:55 -0700282// associated and disassociated with an AudioRtpReceiver.
283TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) {
284 CreateAudioRtpReceiver();
285 DestroyAudioRtpReceiver();
286}
287
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700288// Test that |video_channel_| is updated when a remote video track is
289// associated and disassociated with a VideoRtpReceiver.
deadbeef70ab1a12015-09-28 16:53:55 -0700290TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) {
291 CreateVideoRtpReceiver();
292 DestroyVideoRtpReceiver();
293}
294
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700295// Test that the AudioRtpSender applies options from the local audio source.
296TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) {
297 cricket::AudioOptions options;
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100298 options.echo_cancellation = true;
deadbeef757146b2017-02-10 21:26:48 -0800299 auto source = LocalAudioSource::Create(&options);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700300 CreateAudioRtpSender(source.get());
Taylor Brandstetter2d549172016-06-24 14:18:22 -0700301
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100302 EXPECT_EQ(true, voice_media_channel_->options().echo_cancellation);
Taylor Brandstetter2d549172016-06-24 14:18:22 -0700303
304 DestroyAudioRtpSender();
305}
306
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700307// Test that the stream is muted when the track is disabled, and unmuted when
308// the track is enabled.
309TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) {
310 CreateAudioRtpSender();
311
312 audio_track_->set_enabled(false);
313 EXPECT_TRUE(voice_media_channel_->IsStreamMuted(kAudioSsrc));
314
315 audio_track_->set_enabled(true);
316 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(kAudioSsrc));
317
318 DestroyAudioRtpSender();
319}
320
321// Test that the volume is set to 0 when the track is disabled, and back to
322// 1 when the track is enabled.
deadbeef70ab1a12015-09-28 16:53:55 -0700323TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) {
324 CreateAudioRtpReceiver();
325
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700326 double volume;
327 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
328 EXPECT_EQ(1, volume);
Taylor Brandstetter2d549172016-06-24 14:18:22 -0700329
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700330 audio_track_->set_enabled(false);
331 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
332 EXPECT_EQ(0, volume);
333
deadbeef70ab1a12015-09-28 16:53:55 -0700334 audio_track_->set_enabled(true);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700335 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
336 EXPECT_EQ(1, volume);
deadbeef70ab1a12015-09-28 16:53:55 -0700337
338 DestroyAudioRtpReceiver();
339}
340
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700341// Currently no action is taken when a remote video track is disabled or
342// enabled, so there's nothing to test here, other than what is normally
343// verified in DestroyVideoRtpSender.
deadbeef70ab1a12015-09-28 16:53:55 -0700344TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) {
345 CreateVideoRtpSender();
346
deadbeef70ab1a12015-09-28 16:53:55 -0700347 video_track_->set_enabled(false);
deadbeef70ab1a12015-09-28 16:53:55 -0700348 video_track_->set_enabled(true);
349
350 DestroyVideoRtpSender();
351}
352
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700353// Test that the state of the video track created by the VideoRtpReceiver is
354// updated when the receiver is destroyed.
perkjf0dcfe22016-03-10 18:32:00 +0100355TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) {
356 CreateVideoRtpReceiver();
357
358 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state());
359 EXPECT_EQ(webrtc::MediaSourceInterface::kLive,
360 video_track_->GetSource()->state());
361
362 DestroyVideoRtpReceiver();
363
364 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state());
365 EXPECT_EQ(webrtc::MediaSourceInterface::kEnded,
366 video_track_->GetSource()->state());
367}
368
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700369// Currently no action is taken when a remote video track is disabled or
370// enabled, so there's nothing to test here, other than what is normally
371// verified in DestroyVideoRtpReceiver.
deadbeef70ab1a12015-09-28 16:53:55 -0700372TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) {
373 CreateVideoRtpReceiver();
374
375 video_track_->set_enabled(false);
deadbeef70ab1a12015-09-28 16:53:55 -0700376 video_track_->set_enabled(true);
377
378 DestroyVideoRtpReceiver();
379}
380
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700381// Test that the AudioRtpReceiver applies volume changes from the track source
382// to the media channel.
deadbeef70ab1a12015-09-28 16:53:55 -0700383TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
384 CreateAudioRtpReceiver();
385
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700386 double volume;
387 audio_track_->GetSource()->SetVolume(0.5);
388 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
389 EXPECT_EQ(0.5, volume);
deadbeef70ab1a12015-09-28 16:53:55 -0700390
391 // Disable the audio track, this should prevent setting the volume.
deadbeef70ab1a12015-09-28 16:53:55 -0700392 audio_track_->set_enabled(false);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700393 audio_track_->GetSource()->SetVolume(0.8);
394 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
395 EXPECT_EQ(0, volume);
deadbeef70ab1a12015-09-28 16:53:55 -0700396
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700397 // When the track is enabled, the previously set volume should take effect.
deadbeef70ab1a12015-09-28 16:53:55 -0700398 audio_track_->set_enabled(true);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700399 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
400 EXPECT_EQ(0.8, volume);
deadbeef70ab1a12015-09-28 16:53:55 -0700401
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700402 // Try changing volume one more time.
403 audio_track_->GetSource()->SetVolume(0.9);
404 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
405 EXPECT_EQ(0.9, volume);
deadbeef70ab1a12015-09-28 16:53:55 -0700406
407 DestroyAudioRtpReceiver();
408}
409
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700410// Test that the media channel isn't enabled for sending if the audio sender
411// doesn't have both a track and SSRC.
deadbeeffac06552015-11-25 11:26:01 -0800412TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700413 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 11:26:01 -0800414 rtc::scoped_refptr<AudioTrackInterface> track =
415 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700416
417 // Track but no SSRC.
418 EXPECT_TRUE(audio_rtp_sender_->SetTrack(track));
419 VerifyVoiceChannelNoInput();
420
421 // SSRC but no track.
422 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr));
423 audio_rtp_sender_->SetSsrc(kAudioSsrc);
424 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800425}
426
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700427// Test that the media channel isn't enabled for sending if the video sender
428// doesn't have both a track and SSRC.
deadbeeffac06552015-11-25 11:26:01 -0800429TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700430 video_rtp_sender_ = new VideoRtpSender(video_channel_);
431
432 // Track but no SSRC.
433 EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_));
434 VerifyVideoChannelNoInput();
435
436 // SSRC but no track.
437 EXPECT_TRUE(video_rtp_sender_->SetTrack(nullptr));
438 video_rtp_sender_->SetSsrc(kVideoSsrc);
439 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800440}
441
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700442// Test that the media channel is enabled for sending when the audio sender
443// has a track and SSRC, when the SSRC is set first.
deadbeeffac06552015-11-25 11:26:01 -0800444TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700445 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 11:26:01 -0800446 rtc::scoped_refptr<AudioTrackInterface> track =
447 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700448 audio_rtp_sender_->SetSsrc(kAudioSsrc);
449 audio_rtp_sender_->SetTrack(track);
450 VerifyVoiceChannelInput();
deadbeeffac06552015-11-25 11:26:01 -0800451
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700452 DestroyAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800453}
454
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700455// Test that the media channel is enabled for sending when the audio sender
456// has a track and SSRC, when the SSRC is set last.
deadbeeffac06552015-11-25 11:26:01 -0800457TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700458 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 11:26:01 -0800459 rtc::scoped_refptr<AudioTrackInterface> track =
460 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700461 audio_rtp_sender_->SetTrack(track);
462 audio_rtp_sender_->SetSsrc(kAudioSsrc);
463 VerifyVoiceChannelInput();
deadbeeffac06552015-11-25 11:26:01 -0800464
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700465 DestroyAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800466}
467
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700468// Test that the media channel is enabled for sending when the video sender
469// has a track and SSRC, when the SSRC is set first.
deadbeeffac06552015-11-25 11:26:01 -0800470TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
nisseaf510af2016-03-21 08:20:42 -0700471 AddVideoTrack();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700472 video_rtp_sender_ = new VideoRtpSender(video_channel_);
473 video_rtp_sender_->SetSsrc(kVideoSsrc);
474 video_rtp_sender_->SetTrack(video_track_);
475 VerifyVideoChannelInput();
deadbeeffac06552015-11-25 11:26:01 -0800476
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700477 DestroyVideoRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800478}
479
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700480// Test that the media channel is enabled for sending when the video sender
481// has a track and SSRC, when the SSRC is set last.
deadbeeffac06552015-11-25 11:26:01 -0800482TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) {
nisseaf510af2016-03-21 08:20:42 -0700483 AddVideoTrack();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700484 video_rtp_sender_ = new VideoRtpSender(video_channel_);
485 video_rtp_sender_->SetTrack(video_track_);
486 video_rtp_sender_->SetSsrc(kVideoSsrc);
487 VerifyVideoChannelInput();
deadbeeffac06552015-11-25 11:26:01 -0800488
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700489 DestroyVideoRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800490}
491
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700492// Test that the media channel stops sending when the audio sender's SSRC is set
493// to 0.
deadbeeffac06552015-11-25 11:26:01 -0800494TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700495 CreateAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800496
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700497 audio_rtp_sender_->SetSsrc(0);
498 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800499}
500
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700501// Test that the media channel stops sending when the video sender's SSRC is set
502// to 0.
deadbeeffac06552015-11-25 11:26:01 -0800503TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700504 CreateAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800505
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700506 audio_rtp_sender_->SetSsrc(0);
507 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800508}
509
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700510// Test that the media channel stops sending when the audio sender's track is
511// set to null.
deadbeeffac06552015-11-25 11:26:01 -0800512TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700513 CreateAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800514
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700515 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr));
516 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800517}
518
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700519// Test that the media channel stops sending when the video sender's track is
520// set to null.
deadbeeffac06552015-11-25 11:26:01 -0800521TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700522 CreateVideoRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800523
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700524 video_rtp_sender_->SetSsrc(0);
525 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 11:26:01 -0800526}
527
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700528// Test that when the audio sender's SSRC is changed, the media channel stops
529// sending with the old SSRC and starts sending with the new one.
deadbeeffac06552015-11-25 11:26:01 -0800530TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700531 CreateAudioRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800532
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700533 audio_rtp_sender_->SetSsrc(kAudioSsrc2);
534 VerifyVoiceChannelNoInput(kAudioSsrc);
535 VerifyVoiceChannelInput(kAudioSsrc2);
deadbeeffac06552015-11-25 11:26:01 -0800536
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700537 audio_rtp_sender_ = nullptr;
538 VerifyVoiceChannelNoInput(kAudioSsrc2);
deadbeeffac06552015-11-25 11:26:01 -0800539}
540
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700541// Test that when the audio sender's SSRC is changed, the media channel stops
542// sending with the old SSRC and starts sending with the new one.
deadbeeffac06552015-11-25 11:26:01 -0800543TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) {
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700544 CreateVideoRtpSender();
deadbeeffac06552015-11-25 11:26:01 -0800545
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700546 video_rtp_sender_->SetSsrc(kVideoSsrc2);
547 VerifyVideoChannelNoInput(kVideoSsrc);
548 VerifyVideoChannelInput(kVideoSsrc2);
deadbeeffac06552015-11-25 11:26:01 -0800549
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700550 video_rtp_sender_ = nullptr;
551 VerifyVideoChannelNoInput(kVideoSsrc2);
deadbeeffac06552015-11-25 11:26:01 -0800552}
553
skvladdc1c62c2016-03-16 19:07:43 -0700554TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) {
555 CreateAudioRtpSender();
556
skvladdc1c62c2016-03-16 19:07:43 -0700557 RtpParameters params = audio_rtp_sender_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700558 EXPECT_EQ(1u, params.encodings.size());
skvladdc1c62c2016-03-16 19:07:43 -0700559 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
560
561 DestroyAudioRtpSender();
562}
563
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700564TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
565 CreateAudioRtpSender();
566
567 EXPECT_EQ(-1, voice_media_channel_->max_bps());
568 webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
569 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 12:09:01 -0800570 EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100571 params.encodings[0].max_bitrate_bps = 1000;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700572 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
573
574 // Read back the parameters and verify they have been changed.
575 params = audio_rtp_sender_->GetParameters();
576 EXPECT_EQ(1, params.encodings.size());
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100577 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700578
579 // Verify that the audio channel received the new parameters.
580 params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc);
581 EXPECT_EQ(1, params.encodings.size());
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100582 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700583
584 // Verify that the global bitrate limit has not been changed.
585 EXPECT_EQ(-1, voice_media_channel_->max_bps());
586
587 DestroyAudioRtpSender();
588}
589
skvladdc1c62c2016-03-16 19:07:43 -0700590TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) {
591 CreateVideoRtpSender();
592
skvladdc1c62c2016-03-16 19:07:43 -0700593 RtpParameters params = video_rtp_sender_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700594 EXPECT_EQ(1u, params.encodings.size());
skvladdc1c62c2016-03-16 19:07:43 -0700595 EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
596
597 DestroyVideoRtpSender();
598}
599
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700600TEST_F(RtpSenderReceiverTest, SetVideoMaxSendBitrate) {
601 CreateVideoRtpSender();
602
603 EXPECT_EQ(-1, video_media_channel_->max_bps());
604 webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
605 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 12:09:01 -0800606 EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100607 params.encodings[0].max_bitrate_bps = 1000;
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700608 EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
609
610 // Read back the parameters and verify they have been changed.
611 params = video_rtp_sender_->GetParameters();
612 EXPECT_EQ(1, params.encodings.size());
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100613 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700614
615 // Verify that the video channel received the new parameters.
616 params = video_media_channel_->GetRtpSendParameters(kVideoSsrc);
617 EXPECT_EQ(1, params.encodings.size());
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100618 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700619
620 // Verify that the global bitrate limit has not been changed.
621 EXPECT_EQ(-1, video_media_channel_->max_bps());
622
623 DestroyVideoRtpSender();
624}
625
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700626TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) {
627 CreateAudioRtpReceiver();
628
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700629 RtpParameters params = audio_rtp_receiver_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700630 EXPECT_EQ(1u, params.encodings.size());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700631 EXPECT_TRUE(audio_rtp_receiver_->SetParameters(params));
632
633 DestroyAudioRtpReceiver();
634}
635
636TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetParameters) {
637 CreateVideoRtpReceiver();
638
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700639 RtpParameters params = video_rtp_receiver_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 16:30:35 -0700640 EXPECT_EQ(1u, params.encodings.size());
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -0700641 EXPECT_TRUE(video_rtp_receiver_->SetParameters(params));
642
643 DestroyVideoRtpReceiver();
644}
645
pbos5214a0a2016-12-16 15:39:11 -0800646// Test that makes sure that a video track content hint translates to the proper
647// value for sources that are not screencast.
648TEST_F(RtpSenderReceiverTest, PropagatesVideoTrackContentHint) {
649 CreateVideoRtpSender();
650
651 video_track_->set_enabled(true);
652
653 // |video_track_| is not screencast by default.
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100654 EXPECT_EQ(false, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800655 // No content hint should be set by default.
656 EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
657 video_track_->content_hint());
658 // Setting detailed should turn a non-screencast source into screencast mode.
659 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100660 EXPECT_EQ(true, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800661 // Removing the content hint should turn the track back into non-screencast
662 // mode.
663 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100664 EXPECT_EQ(false, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800665 // Setting fluid should remain in non-screencast mode (its default).
666 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100667 EXPECT_EQ(false, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800668
669 DestroyVideoRtpSender();
670}
671
672// Test that makes sure that a video track content hint translates to the proper
673// value for screencast sources.
674TEST_F(RtpSenderReceiverTest,
675 PropagatesVideoTrackContentHintForScreencastSource) {
676 CreateVideoRtpSender(true);
677
678 video_track_->set_enabled(true);
679
680 // |video_track_| with a screencast source should be screencast by default.
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100681 EXPECT_EQ(true, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800682 // No content hint should be set by default.
683 EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
684 video_track_->content_hint());
685 // Setting fluid should turn a screencast source into non-screencast mode.
686 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100687 EXPECT_EQ(false, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800688 // Removing the content hint should turn the track back into screencast mode.
689 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100690 EXPECT_EQ(true, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800691 // Setting detailed should still remain in screencast mode (its default).
692 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100693 EXPECT_EQ(true, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800694
695 DestroyVideoRtpSender();
696}
697
698// Test that makes sure any content hints that are set on a track before
699// VideoRtpSender is ready to send are still applied when it gets ready to send.
700TEST_F(RtpSenderReceiverTest,
701 PropagatesVideoTrackContentHintSetBeforeEnabling) {
702 AddVideoTrack();
703 // Setting detailed overrides the default non-screencast mode. This should be
704 // applied even if the track is set on construction.
705 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
deadbeefe814a0d2017-02-25 18:15:09 -0800706 video_rtp_sender_ =
707 new VideoRtpSender(local_stream_->GetVideoTracks()[0],
Steve Anton8ffb9c32017-08-31 15:45:38 -0700708 {local_stream_->label()}, video_channel_);
pbos5214a0a2016-12-16 15:39:11 -0800709 video_track_->set_enabled(true);
710
711 // Sender is not ready to send (no SSRC) so no option should have been set.
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100712 EXPECT_EQ(rtc::nullopt, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800713
714 // Verify that the content hint is accounted for when video_rtp_sender_ does
715 // get enabled.
716 video_rtp_sender_->SetSsrc(kVideoSsrc);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100717 EXPECT_EQ(true, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800718
719 // And removing the hint should go back to false (to verify that false was
720 // default correctly).
721 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +0100722 EXPECT_EQ(false, video_media_channel_->options().is_screencast);
pbos5214a0a2016-12-16 15:39:11 -0800723
724 DestroyVideoRtpSender();
725}
726
deadbeef20cb0c12017-02-01 20:27:00 -0800727TEST_F(RtpSenderReceiverTest, AudioSenderHasDtmfSender) {
728 CreateAudioRtpSender();
729 EXPECT_NE(nullptr, audio_rtp_sender_->GetDtmfSender());
730}
731
732TEST_F(RtpSenderReceiverTest, VideoSenderDoesNotHaveDtmfSender) {
733 CreateVideoRtpSender();
734 EXPECT_EQ(nullptr, video_rtp_sender_->GetDtmfSender());
735}
736
737// Test that the DTMF sender is really using |voice_channel_|, and thus returns
738// true/false from CanSendDtmf based on what |voice_channel_| returns.
739TEST_F(RtpSenderReceiverTest, CanInsertDtmf) {
740 AddDtmfCodec();
741 CreateAudioRtpSender();
742 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
743 ASSERT_NE(nullptr, dtmf_sender);
744 EXPECT_TRUE(dtmf_sender->CanInsertDtmf());
745}
746
747TEST_F(RtpSenderReceiverTest, CanNotInsertDtmf) {
748 CreateAudioRtpSender();
749 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
750 ASSERT_NE(nullptr, dtmf_sender);
751 // DTMF codec has not been added, as it was in the above test.
752 EXPECT_FALSE(dtmf_sender->CanInsertDtmf());
753}
754
755TEST_F(RtpSenderReceiverTest, InsertDtmf) {
756 AddDtmfCodec();
757 CreateAudioRtpSender();
758 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
759 ASSERT_NE(nullptr, dtmf_sender);
760
761 EXPECT_EQ(0U, voice_media_channel_->dtmf_info_queue().size());
762
763 // Insert DTMF
764 const int expected_duration = 90;
765 dtmf_sender->InsertDtmf("012", expected_duration, 100);
766
767 // Verify
768 ASSERT_EQ_WAIT(3U, voice_media_channel_->dtmf_info_queue().size(),
769 kDefaultTimeout);
770 const uint32_t send_ssrc =
771 voice_media_channel_->send_streams()[0].first_ssrc();
772 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[0],
773 send_ssrc, 0, expected_duration));
774 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[1],
775 send_ssrc, 1, expected_duration));
776 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[2],
777 send_ssrc, 2, expected_duration));
778}
779
780// Make sure the signal from "GetOnDestroyedSignal()" fires when the sender is
781// destroyed, which is needed for the DTMF sender.
782TEST_F(RtpSenderReceiverTest, TestOnDestroyedSignal) {
783 CreateAudioRtpSender();
784 EXPECT_FALSE(audio_sender_destroyed_signal_fired_);
785 audio_rtp_sender_ = nullptr;
786 EXPECT_TRUE(audio_sender_destroyed_signal_fired_);
787}
788
deadbeef70ab1a12015-09-28 16:53:55 -0700789} // namespace webrtc