OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 #include <string> | 12 #include <string> |
13 #include <utility> | 13 #include <utility> |
14 | 14 |
15 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "webrtc/api/audiotrack.h" | 17 #include "webrtc/api/audiotrack.h" |
| 18 #include "webrtc/api/fakemediacontroller.h" |
| 19 #include "webrtc/api/localaudiosource.h" |
18 #include "webrtc/api/mediastream.h" | 20 #include "webrtc/api/mediastream.h" |
19 #include "webrtc/api/remoteaudiosource.h" | 21 #include "webrtc/api/remoteaudiosource.h" |
20 #include "webrtc/api/rtpreceiver.h" | 22 #include "webrtc/api/rtpreceiver.h" |
21 #include "webrtc/api/rtpsender.h" | 23 #include "webrtc/api/rtpsender.h" |
22 #include "webrtc/api/streamcollection.h" | 24 #include "webrtc/api/streamcollection.h" |
23 #include "webrtc/api/test/fakevideotracksource.h" | 25 #include "webrtc/api/test/fakevideotracksource.h" |
24 #include "webrtc/api/videotracksource.h" | 26 #include "webrtc/api/videotracksource.h" |
25 #include "webrtc/api/videotrack.h" | 27 #include "webrtc/api/videotrack.h" |
26 #include "webrtc/base/gunit.h" | 28 #include "webrtc/base/gunit.h" |
27 #include "webrtc/media/base/mediachannel.h" | 29 #include "webrtc/media/base/mediachannel.h" |
| 30 #include "webrtc/media/base/fakemediaengine.h" |
| 31 #include "webrtc/media/engine/fakewebrtccall.h" |
| 32 #include "webrtc/p2p/base/faketransportcontroller.h" |
| 33 #include "webrtc/pc/channelmanager.h" |
28 | 34 |
29 using ::testing::_; | 35 using ::testing::_; |
30 using ::testing::Exactly; | 36 using ::testing::Exactly; |
31 using ::testing::InvokeWithoutArgs; | 37 using ::testing::InvokeWithoutArgs; |
32 using ::testing::Return; | 38 using ::testing::Return; |
33 | 39 |
34 static const char kStreamLabel1[] = "local_stream_1"; | 40 static const char kStreamLabel1[] = "local_stream_1"; |
35 static const char kVideoTrackId[] = "video_1"; | 41 static const char kVideoTrackId[] = "video_1"; |
36 static const char kAudioTrackId[] = "audio_1"; | 42 static const char kAudioTrackId[] = "audio_1"; |
37 static const uint32_t kVideoSsrc = 98; | 43 static const uint32_t kVideoSsrc = 98; |
38 static const uint32_t kVideoSsrc2 = 100; | 44 static const uint32_t kVideoSsrc2 = 100; |
39 static const uint32_t kAudioSsrc = 99; | 45 static const uint32_t kAudioSsrc = 99; |
40 static const uint32_t kAudioSsrc2 = 101; | 46 static const uint32_t kAudioSsrc2 = 101; |
41 | 47 |
42 namespace webrtc { | 48 namespace webrtc { |
43 | 49 |
44 // Helper class to test RtpSender/RtpReceiver. | 50 class RtpSenderReceiverTest : public testing::Test { |
45 class MockAudioProvider : public AudioProviderInterface { | |
46 public: | 51 public: |
47 // TODO(nisse): Valid overrides commented out, because the gmock | 52 RtpSenderReceiverTest() |
48 // methods don't use any override declarations, and we want to avoid | 53 : // Create fake media engine/etc. so we can create channels to use to |
49 // warnings from -Winconsistent-missing-override. See | 54 // test RtpSenders/RtpReceivers. |
50 // http://crbug.com/428099. | 55 media_engine_(new cricket::FakeMediaEngine()), |
51 ~MockAudioProvider() /* override */ {} | 56 channel_manager_(media_engine_, |
| 57 rtc::Thread::Current(), |
| 58 rtc::Thread::Current()), |
| 59 fake_call_(webrtc::Call::Config()), |
| 60 fake_media_controller_(&channel_manager_, &fake_call_), |
| 61 stream_(MediaStream::Create(kStreamLabel1)) { |
| 62 // Create channels to be used by the RtpSenders and RtpReceivers. |
| 63 channel_manager_.Init(); |
| 64 voice_channel_ = channel_manager_.CreateVoiceChannel( |
| 65 &fake_media_controller_, &fake_transport_controller_, cricket::CN_AUDIO, |
| 66 nullptr, false, cricket::AudioOptions()); |
| 67 video_channel_ = channel_manager_.CreateVideoChannel( |
| 68 &fake_media_controller_, &fake_transport_controller_, cricket::CN_VIDEO, |
| 69 nullptr, false, cricket::VideoOptions()); |
| 70 voice_media_channel_ = media_engine_->GetVoiceChannel(0); |
| 71 video_media_channel_ = media_engine_->GetVideoChannel(0); |
| 72 RTC_CHECK(voice_channel_); |
| 73 RTC_CHECK(video_channel_); |
| 74 RTC_CHECK(voice_media_channel_); |
| 75 RTC_CHECK(video_media_channel_); |
52 | 76 |
53 MOCK_METHOD2(SetAudioPlayout, | 77 // Create streams for predefined SSRCs. Streams need to exist in order |
54 void(uint32_t ssrc, | 78 // for the senders and receievers to apply parameters to them. |
55 bool enable)); | 79 // Normally these would be created by SetLocalDescription and |
56 MOCK_METHOD4(SetAudioSend, | 80 // SetRemoteDescription. |
57 void(uint32_t ssrc, | 81 voice_media_channel_->AddSendStream( |
58 bool enable, | 82 cricket::StreamParams::CreateLegacy(kAudioSsrc)); |
59 const cricket::AudioOptions& options, | 83 voice_media_channel_->AddRecvStream( |
60 cricket::AudioSource* source)); | 84 cricket::StreamParams::CreateLegacy(kAudioSsrc)); |
61 MOCK_METHOD2(SetAudioPlayoutVolume, void(uint32_t ssrc, double volume)); | 85 voice_media_channel_->AddSendStream( |
62 MOCK_CONST_METHOD1(GetAudioRtpSendParameters, RtpParameters(uint32_t ssrc)); | 86 cricket::StreamParams::CreateLegacy(kAudioSsrc2)); |
63 MOCK_METHOD2(SetAudioRtpSendParameters, | 87 voice_media_channel_->AddRecvStream( |
64 bool(uint32_t ssrc, const RtpParameters&)); | 88 cricket::StreamParams::CreateLegacy(kAudioSsrc2)); |
65 MOCK_CONST_METHOD1(GetAudioRtpReceiveParameters, | 89 video_media_channel_->AddSendStream( |
66 RtpParameters(uint32_t ssrc)); | 90 cricket::StreamParams::CreateLegacy(kVideoSsrc)); |
67 MOCK_METHOD2(SetAudioRtpReceiveParameters, | 91 video_media_channel_->AddRecvStream( |
68 bool(uint32_t ssrc, const RtpParameters&)); | 92 cricket::StreamParams::CreateLegacy(kVideoSsrc)); |
69 | 93 video_media_channel_->AddSendStream( |
70 void SetRawAudioSink( | 94 cricket::StreamParams::CreateLegacy(kVideoSsrc2)); |
71 uint32_t, std::unique_ptr<AudioSinkInterface> sink) /* override */ { | 95 video_media_channel_->AddRecvStream( |
72 sink_ = std::move(sink); | 96 cricket::StreamParams::CreateLegacy(kVideoSsrc2)); |
73 } | 97 } |
74 | 98 |
75 private: | 99 void TearDown() override { channel_manager_.Terminate(); } |
76 std::unique_ptr<AudioSinkInterface> sink_; | |
77 }; | |
78 | |
79 // Helper class to test RtpSender/RtpReceiver. | |
80 class MockVideoProvider : public VideoProviderInterface { | |
81 public: | |
82 virtual ~MockVideoProvider() {} | |
83 MOCK_METHOD3(SetVideoPlayout, | |
84 void(uint32_t ssrc, | |
85 bool enable, | |
86 rtc::VideoSinkInterface<cricket::VideoFrame>* sink)); | |
87 MOCK_METHOD4(SetVideoSend, | |
88 void(uint32_t ssrc, | |
89 bool enable, | |
90 const cricket::VideoOptions* options, | |
91 rtc::VideoSourceInterface<cricket::VideoFrame>* source)); | |
92 | |
93 MOCK_CONST_METHOD1(GetVideoRtpSendParameters, RtpParameters(uint32_t ssrc)); | |
94 MOCK_METHOD2(SetVideoRtpSendParameters, | |
95 bool(uint32_t ssrc, const RtpParameters&)); | |
96 MOCK_CONST_METHOD1(GetVideoRtpReceiveParameters, | |
97 RtpParameters(uint32_t ssrc)); | |
98 MOCK_METHOD2(SetVideoRtpReceiveParameters, | |
99 bool(uint32_t ssrc, const RtpParameters&)); | |
100 }; | |
101 | |
102 class RtpSenderReceiverTest : public testing::Test { | |
103 public: | |
104 virtual void SetUp() { | |
105 stream_ = MediaStream::Create(kStreamLabel1); | |
106 } | |
107 | 100 |
108 void AddVideoTrack() { | 101 void AddVideoTrack() { |
109 rtc::scoped_refptr<VideoTrackSourceInterface> source( | 102 rtc::scoped_refptr<VideoTrackSourceInterface> source( |
110 FakeVideoTrackSource::Create()); | 103 FakeVideoTrackSource::Create()); |
111 video_track_ = VideoTrack::Create(kVideoTrackId, source); | 104 video_track_ = VideoTrack::Create(kVideoTrackId, source); |
112 EXPECT_TRUE(stream_->AddTrack(video_track_)); | 105 EXPECT_TRUE(stream_->AddTrack(video_track_)); |
113 } | 106 } |
114 | 107 |
115 void CreateAudioRtpSender() { | 108 void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); } |
116 audio_track_ = AudioTrack::Create(kAudioTrackId, NULL); | 109 |
| 110 void CreateAudioRtpSender(rtc::scoped_refptr<LocalAudioSource> source) { |
| 111 audio_track_ = AudioTrack::Create(kAudioTrackId, source); |
117 EXPECT_TRUE(stream_->AddTrack(audio_track_)); | 112 EXPECT_TRUE(stream_->AddTrack(audio_track_)); |
118 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | |
119 audio_rtp_sender_ = | 113 audio_rtp_sender_ = |
120 new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(), | 114 new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(), |
121 &audio_provider_, nullptr); | 115 voice_channel_, nullptr); |
122 audio_rtp_sender_->SetSsrc(kAudioSsrc); | 116 audio_rtp_sender_->SetSsrc(kAudioSsrc); |
| 117 VerifyVoiceChannelInput(); |
123 } | 118 } |
124 | 119 |
125 void CreateVideoRtpSender() { | 120 void CreateVideoRtpSender() { |
126 AddVideoTrack(); | 121 AddVideoTrack(); |
127 EXPECT_CALL(video_provider_, | |
128 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | |
129 video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0], | 122 video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0], |
130 stream_->label(), &video_provider_); | 123 stream_->label(), video_channel_); |
131 video_rtp_sender_->SetSsrc(kVideoSsrc); | 124 video_rtp_sender_->SetSsrc(kVideoSsrc); |
| 125 VerifyVideoChannelInput(); |
132 } | 126 } |
133 | 127 |
134 void DestroyAudioRtpSender() { | 128 void DestroyAudioRtpSender() { |
135 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)) | |
136 .Times(1); | |
137 audio_rtp_sender_ = nullptr; | 129 audio_rtp_sender_ = nullptr; |
| 130 VerifyVoiceChannelNoInput(); |
138 } | 131 } |
139 | 132 |
140 void DestroyVideoRtpSender() { | 133 void DestroyVideoRtpSender() { |
141 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | |
142 .Times(1); | |
143 video_rtp_sender_ = nullptr; | 134 video_rtp_sender_ = nullptr; |
| 135 VerifyVideoChannelNoInput(); |
144 } | 136 } |
145 | 137 |
146 void CreateAudioRtpReceiver() { | 138 void CreateAudioRtpReceiver() { |
147 audio_track_ = AudioTrack::Create( | 139 audio_track_ = AudioTrack::Create( |
148 kAudioTrackId, RemoteAudioSource::Create(kAudioSsrc, NULL)); | 140 kAudioTrackId, RemoteAudioSource::Create(kAudioSsrc, NULL)); |
149 EXPECT_TRUE(stream_->AddTrack(audio_track_)); | 141 EXPECT_TRUE(stream_->AddTrack(audio_track_)); |
150 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true)); | |
151 audio_rtp_receiver_ = new AudioRtpReceiver(stream_, kAudioTrackId, | 142 audio_rtp_receiver_ = new AudioRtpReceiver(stream_, kAudioTrackId, |
152 kAudioSsrc, &audio_provider_); | 143 kAudioSsrc, voice_channel_); |
153 audio_track_ = audio_rtp_receiver_->audio_track(); | 144 audio_track_ = audio_rtp_receiver_->audio_track(); |
| 145 VerifyVoiceChannelOutput(); |
154 } | 146 } |
155 | 147 |
156 void CreateVideoRtpReceiver() { | 148 void CreateVideoRtpReceiver() { |
157 EXPECT_CALL(video_provider_, SetVideoPlayout(kVideoSsrc, true, _)); | |
158 video_rtp_receiver_ = | 149 video_rtp_receiver_ = |
159 new VideoRtpReceiver(stream_, kVideoTrackId, rtc::Thread::Current(), | 150 new VideoRtpReceiver(stream_, kVideoTrackId, rtc::Thread::Current(), |
160 kVideoSsrc, &video_provider_); | 151 kVideoSsrc, video_channel_); |
161 video_track_ = video_rtp_receiver_->video_track(); | 152 video_track_ = video_rtp_receiver_->video_track(); |
| 153 VerifyVideoChannelOutput(); |
162 } | 154 } |
163 | 155 |
164 void DestroyAudioRtpReceiver() { | 156 void DestroyAudioRtpReceiver() { |
165 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false)); | |
166 audio_rtp_receiver_ = nullptr; | 157 audio_rtp_receiver_ = nullptr; |
| 158 VerifyVoiceChannelNoOutput(); |
167 } | 159 } |
168 | 160 |
169 void DestroyVideoRtpReceiver() { | 161 void DestroyVideoRtpReceiver() { |
170 EXPECT_CALL(video_provider_, SetVideoPlayout(kVideoSsrc, false, NULL)); | |
171 video_rtp_receiver_ = nullptr; | 162 video_rtp_receiver_ = nullptr; |
| 163 VerifyVideoChannelNoOutput(); |
| 164 } |
| 165 |
| 166 void VerifyVoiceChannelInput() { VerifyVoiceChannelInput(kAudioSsrc); } |
| 167 |
| 168 void VerifyVoiceChannelInput(uint32_t ssrc) { |
| 169 // Verify that the media channel has an audio source, and the stream isn't |
| 170 // muted. |
| 171 EXPECT_TRUE(voice_media_channel_->HasSource(ssrc)); |
| 172 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(ssrc)); |
| 173 } |
| 174 |
| 175 void VerifyVideoChannelInput() { VerifyVideoChannelInput(kVideoSsrc); } |
| 176 |
| 177 void VerifyVideoChannelInput(uint32_t ssrc) { |
| 178 // Verify that the media channel has a video source, |
| 179 EXPECT_TRUE(video_media_channel_->HasSource(ssrc)); |
| 180 } |
| 181 |
| 182 void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); } |
| 183 |
| 184 void VerifyVoiceChannelNoInput(uint32_t ssrc) { |
| 185 // Verify that the media channel's source is reset. |
| 186 EXPECT_FALSE(voice_media_channel_->HasSource(ssrc)); |
| 187 } |
| 188 |
| 189 void VerifyVideoChannelNoInput() { VerifyVideoChannelNoInput(kVideoSsrc); } |
| 190 |
| 191 void VerifyVideoChannelNoInput(uint32_t ssrc) { |
| 192 // Verify that the media channel's source is reset. |
| 193 EXPECT_FALSE(video_media_channel_->HasSource(ssrc)); |
| 194 } |
| 195 |
| 196 void VerifyVoiceChannelOutput() { |
| 197 // Verify that the volume is initialized to 1. |
| 198 double volume; |
| 199 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 200 EXPECT_EQ(1, volume); |
| 201 } |
| 202 |
| 203 void VerifyVideoChannelOutput() { |
| 204 // Verify that the media channel has a sink. |
| 205 EXPECT_TRUE(video_media_channel_->HasSink(kVideoSsrc)); |
| 206 } |
| 207 |
| 208 void VerifyVoiceChannelNoOutput() { |
| 209 // Verify that the volume is reset to 0. |
| 210 double volume; |
| 211 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 212 EXPECT_EQ(0, volume); |
| 213 } |
| 214 |
| 215 void VerifyVideoChannelNoOutput() { |
| 216 // Verify that the media channel's sink is reset. |
| 217 EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc)); |
172 } | 218 } |
173 | 219 |
174 protected: | 220 protected: |
175 MockAudioProvider audio_provider_; | 221 cricket::FakeMediaEngine* media_engine_; |
176 MockVideoProvider video_provider_; | 222 cricket::FakeTransportController fake_transport_controller_; |
| 223 cricket::ChannelManager channel_manager_; |
| 224 cricket::FakeCall fake_call_; |
| 225 cricket::FakeMediaController fake_media_controller_; |
| 226 cricket::VoiceChannel* voice_channel_; |
| 227 cricket::VideoChannel* video_channel_; |
| 228 cricket::FakeVoiceMediaChannel* voice_media_channel_; |
| 229 cricket::FakeVideoMediaChannel* video_media_channel_; |
177 rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_; | 230 rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_; |
178 rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_; | 231 rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_; |
179 rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_; | 232 rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_; |
180 rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_; | 233 rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_; |
181 rtc::scoped_refptr<MediaStreamInterface> stream_; | 234 rtc::scoped_refptr<MediaStreamInterface> stream_; |
182 rtc::scoped_refptr<VideoTrackInterface> video_track_; | 235 rtc::scoped_refptr<VideoTrackInterface> video_track_; |
183 rtc::scoped_refptr<AudioTrackInterface> audio_track_; | 236 rtc::scoped_refptr<AudioTrackInterface> audio_track_; |
184 }; | 237 }; |
185 | 238 |
186 // Test that |audio_provider_| is notified when an audio track is associated | 239 // Test that |voice_channel_| is updated when an audio track is associated |
187 // and disassociated with an AudioRtpSender. | 240 // and disassociated with an AudioRtpSender. |
188 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) { | 241 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) { |
189 CreateAudioRtpSender(); | 242 CreateAudioRtpSender(); |
190 DestroyAudioRtpSender(); | 243 DestroyAudioRtpSender(); |
191 } | 244 } |
192 | 245 |
193 // Test that |video_provider_| is notified when a video track is associated and | 246 // Test that |video_channel_| is updated when a video track is associated and |
194 // disassociated with a VideoRtpSender. | 247 // disassociated with a VideoRtpSender. |
195 TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) { | 248 TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) { |
196 CreateVideoRtpSender(); | 249 CreateVideoRtpSender(); |
197 DestroyVideoRtpSender(); | 250 DestroyVideoRtpSender(); |
198 } | 251 } |
199 | 252 |
200 // Test that |audio_provider_| is notified when a remote audio and track is | 253 // Test that |voice_channel_| is updated when a remote audio track is |
201 // associated and disassociated with an AudioRtpReceiver. | 254 // associated and disassociated with an AudioRtpReceiver. |
202 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) { | 255 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) { |
203 CreateAudioRtpReceiver(); | 256 CreateAudioRtpReceiver(); |
204 DestroyAudioRtpReceiver(); | 257 DestroyAudioRtpReceiver(); |
205 } | 258 } |
206 | 259 |
207 // Test that |video_provider_| is notified when a remote | 260 // Test that |video_channel_| is updated when a remote video track is |
208 // video track is associated and disassociated with a VideoRtpReceiver. | 261 // associated and disassociated with a VideoRtpReceiver. |
209 TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) { | 262 TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) { |
210 CreateVideoRtpReceiver(); | 263 CreateVideoRtpReceiver(); |
211 DestroyVideoRtpReceiver(); | 264 DestroyVideoRtpReceiver(); |
212 } | 265 } |
213 | 266 |
214 TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) { | 267 // Test that the AudioRtpSender applies options from the local audio source. |
215 CreateAudioRtpSender(); | 268 TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) { |
| 269 cricket::AudioOptions options; |
| 270 options.echo_cancellation = rtc::Optional<bool>(true); |
| 271 auto source = LocalAudioSource::Create( |
| 272 PeerConnectionFactoryInterface::Options(), &options); |
| 273 CreateAudioRtpSender(source.get()); |
216 | 274 |
217 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)); | 275 EXPECT_EQ(rtc::Optional<bool>(true), |
218 audio_track_->set_enabled(false); | 276 voice_media_channel_->options().echo_cancellation); |
219 | |
220 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | |
221 audio_track_->set_enabled(true); | |
222 | 277 |
223 DestroyAudioRtpSender(); | 278 DestroyAudioRtpSender(); |
224 } | 279 } |
225 | 280 |
| 281 // Test that the stream is muted when the track is disabled, and unmuted when |
| 282 // the track is enabled. |
| 283 TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) { |
| 284 CreateAudioRtpSender(); |
| 285 |
| 286 audio_track_->set_enabled(false); |
| 287 EXPECT_TRUE(voice_media_channel_->IsStreamMuted(kAudioSsrc)); |
| 288 |
| 289 audio_track_->set_enabled(true); |
| 290 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(kAudioSsrc)); |
| 291 |
| 292 DestroyAudioRtpSender(); |
| 293 } |
| 294 |
| 295 // Test that the volume is set to 0 when the track is disabled, and back to |
| 296 // 1 when the track is enabled. |
226 TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) { | 297 TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) { |
227 CreateAudioRtpReceiver(); | 298 CreateAudioRtpReceiver(); |
228 | 299 |
229 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false)); | 300 double volume; |
| 301 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 302 EXPECT_EQ(1, volume); |
| 303 |
230 audio_track_->set_enabled(false); | 304 audio_track_->set_enabled(false); |
| 305 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 306 EXPECT_EQ(0, volume); |
231 | 307 |
232 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true)); | |
233 audio_track_->set_enabled(true); | 308 audio_track_->set_enabled(true); |
| 309 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 310 EXPECT_EQ(1, volume); |
234 | 311 |
235 DestroyAudioRtpReceiver(); | 312 DestroyAudioRtpReceiver(); |
236 } | 313 } |
237 | 314 |
| 315 // Currently no action is taken when a remote video track is disabled or |
| 316 // enabled, so there's nothing to test here, other than what is normally |
| 317 // verified in DestroyVideoRtpSender. |
238 TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) { | 318 TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) { |
239 CreateVideoRtpSender(); | 319 CreateVideoRtpSender(); |
240 | 320 |
241 EXPECT_CALL(video_provider_, | |
242 SetVideoSend(kVideoSsrc, false, _, video_track_.get())); | |
243 video_track_->set_enabled(false); | 321 video_track_->set_enabled(false); |
244 | |
245 EXPECT_CALL(video_provider_, | |
246 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | |
247 video_track_->set_enabled(true); | 322 video_track_->set_enabled(true); |
248 | 323 |
249 DestroyVideoRtpSender(); | 324 DestroyVideoRtpSender(); |
250 } | 325 } |
251 | 326 |
| 327 // Test that the state of the video track created by the VideoRtpReceiver is |
| 328 // updated when the receiver is destroyed. |
252 TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) { | 329 TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) { |
253 CreateVideoRtpReceiver(); | 330 CreateVideoRtpReceiver(); |
254 | 331 |
255 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state()); | 332 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state()); |
256 EXPECT_EQ(webrtc::MediaSourceInterface::kLive, | 333 EXPECT_EQ(webrtc::MediaSourceInterface::kLive, |
257 video_track_->GetSource()->state()); | 334 video_track_->GetSource()->state()); |
258 | 335 |
259 DestroyVideoRtpReceiver(); | 336 DestroyVideoRtpReceiver(); |
260 | 337 |
261 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state()); | 338 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state()); |
262 EXPECT_EQ(webrtc::MediaSourceInterface::kEnded, | 339 EXPECT_EQ(webrtc::MediaSourceInterface::kEnded, |
263 video_track_->GetSource()->state()); | 340 video_track_->GetSource()->state()); |
264 } | 341 } |
265 | 342 |
| 343 // Currently no action is taken when a remote video track is disabled or |
| 344 // enabled, so there's nothing to test here, other than what is normally |
| 345 // verified in DestroyVideoRtpReceiver. |
266 TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) { | 346 TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) { |
267 CreateVideoRtpReceiver(); | 347 CreateVideoRtpReceiver(); |
268 | 348 |
269 video_track_->set_enabled(false); | 349 video_track_->set_enabled(false); |
270 | |
271 video_track_->set_enabled(true); | 350 video_track_->set_enabled(true); |
272 | 351 |
273 DestroyVideoRtpReceiver(); | 352 DestroyVideoRtpReceiver(); |
274 } | 353 } |
275 | 354 |
| 355 // Test that the AudioRtpReceiver applies volume changes from the track source |
| 356 // to the media channel. |
276 TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) { | 357 TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) { |
277 CreateAudioRtpReceiver(); | 358 CreateAudioRtpReceiver(); |
278 | 359 |
279 double volume = 0.5; | 360 double volume; |
280 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, volume)); | 361 audio_track_->GetSource()->SetVolume(0.5); |
281 audio_track_->GetSource()->SetVolume(volume); | 362 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 363 EXPECT_EQ(0.5, volume); |
282 | 364 |
283 // Disable the audio track, this should prevent setting the volume. | 365 // Disable the audio track, this should prevent setting the volume. |
284 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, false)); | |
285 audio_track_->set_enabled(false); | 366 audio_track_->set_enabled(false); |
286 audio_track_->GetSource()->SetVolume(1.0); | 367 audio_track_->GetSource()->SetVolume(0.8); |
287 | 368 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
288 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true)); | 369 EXPECT_EQ(0, volume); |
| 370 |
| 371 // When the track is enabled, the previously set volume should take effect. |
289 audio_track_->set_enabled(true); | 372 audio_track_->set_enabled(true); |
290 | 373 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
291 double new_volume = 0.8; | 374 EXPECT_EQ(0.8, volume); |
292 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, new_volume)); | 375 |
293 audio_track_->GetSource()->SetVolume(new_volume); | 376 // Try changing volume one more time. |
| 377 audio_track_->GetSource()->SetVolume(0.9); |
| 378 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume)); |
| 379 EXPECT_EQ(0.9, volume); |
294 | 380 |
295 DestroyAudioRtpReceiver(); | 381 DestroyAudioRtpReceiver(); |
296 } | 382 } |
297 | 383 |
298 // Test that provider methods aren't called without both a track and an SSRC. | 384 // Test that the media channel isn't enabled for sending if the audio sender |
| 385 // doesn't have both a track and SSRC. |
299 TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) { | 386 TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) { |
300 rtc::scoped_refptr<AudioRtpSender> sender = | 387 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr); |
301 new AudioRtpSender(&audio_provider_, nullptr); | |
302 rtc::scoped_refptr<AudioTrackInterface> track = | 388 rtc::scoped_refptr<AudioTrackInterface> track = |
303 AudioTrack::Create(kAudioTrackId, nullptr); | 389 AudioTrack::Create(kAudioTrackId, nullptr); |
304 EXPECT_TRUE(sender->SetTrack(track)); | 390 |
305 EXPECT_TRUE(sender->SetTrack(nullptr)); | 391 // Track but no SSRC. |
306 sender->SetSsrc(kAudioSsrc); | 392 EXPECT_TRUE(audio_rtp_sender_->SetTrack(track)); |
307 sender->SetSsrc(0); | 393 VerifyVoiceChannelNoInput(); |
308 // Just let it get destroyed and make sure it doesn't call any methods on the | 394 |
309 // provider interface. | 395 // SSRC but no track. |
310 } | 396 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr)); |
311 | 397 audio_rtp_sender_->SetSsrc(kAudioSsrc); |
312 // Test that provider methods aren't called without both a track and an SSRC. | 398 VerifyVoiceChannelNoInput(); |
| 399 } |
| 400 |
| 401 // Test that the media channel isn't enabled for sending if the video sender |
| 402 // doesn't have both a track and SSRC. |
313 TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) { | 403 TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) { |
314 rtc::scoped_refptr<VideoRtpSender> sender = | 404 video_rtp_sender_ = new VideoRtpSender(video_channel_); |
315 new VideoRtpSender(&video_provider_); | 405 |
316 EXPECT_TRUE(sender->SetTrack(video_track_)); | 406 // Track but no SSRC. |
317 EXPECT_TRUE(sender->SetTrack(nullptr)); | 407 EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_)); |
318 sender->SetSsrc(kVideoSsrc); | 408 VerifyVideoChannelNoInput(); |
319 sender->SetSsrc(0); | 409 |
320 // Just let it get destroyed and make sure it doesn't call any methods on the | 410 // SSRC but no track. |
321 // provider interface. | 411 EXPECT_TRUE(video_rtp_sender_->SetTrack(nullptr)); |
322 } | 412 video_rtp_sender_->SetSsrc(kVideoSsrc); |
323 | 413 VerifyVideoChannelNoInput(); |
324 // Test that an audio sender calls the expected methods on the provider once | 414 } |
325 // it has a track and SSRC, when the SSRC is set first. | 415 |
| 416 // Test that the media channel is enabled for sending when the audio sender |
| 417 // has a track and SSRC, when the SSRC is set first. |
326 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) { | 418 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) { |
327 rtc::scoped_refptr<AudioRtpSender> sender = | 419 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr); |
328 new AudioRtpSender(&audio_provider_, nullptr); | |
329 rtc::scoped_refptr<AudioTrackInterface> track = | 420 rtc::scoped_refptr<AudioTrackInterface> track = |
330 AudioTrack::Create(kAudioTrackId, nullptr); | 421 AudioTrack::Create(kAudioTrackId, nullptr); |
331 sender->SetSsrc(kAudioSsrc); | 422 audio_rtp_sender_->SetSsrc(kAudioSsrc); |
332 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 423 audio_rtp_sender_->SetTrack(track); |
333 sender->SetTrack(track); | 424 VerifyVoiceChannelInput(); |
334 | 425 |
335 // Calls expected from destructor. | 426 DestroyAudioRtpSender(); |
336 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); | 427 } |
337 } | 428 |
338 | 429 // Test that the media channel is enabled for sending when the audio sender |
339 // Test that an audio sender calls the expected methods on the provider once | 430 // has a track and SSRC, when the SSRC is set last. |
340 // it has a track and SSRC, when the SSRC is set last. | |
341 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) { | 431 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) { |
342 rtc::scoped_refptr<AudioRtpSender> sender = | 432 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr); |
343 new AudioRtpSender(&audio_provider_, nullptr); | |
344 rtc::scoped_refptr<AudioTrackInterface> track = | 433 rtc::scoped_refptr<AudioTrackInterface> track = |
345 AudioTrack::Create(kAudioTrackId, nullptr); | 434 AudioTrack::Create(kAudioTrackId, nullptr); |
346 sender->SetTrack(track); | 435 audio_rtp_sender_->SetTrack(track); |
347 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 436 audio_rtp_sender_->SetSsrc(kAudioSsrc); |
348 sender->SetSsrc(kAudioSsrc); | 437 VerifyVoiceChannelInput(); |
349 | 438 |
350 // Calls expected from destructor. | 439 DestroyAudioRtpSender(); |
351 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); | 440 } |
352 } | 441 |
353 | 442 // Test that the media channel is enabled for sending when the video sender |
354 // Test that a video sender calls the expected methods on the provider once | 443 // has a track and SSRC, when the SSRC is set first. |
355 // it has a track and SSRC, when the SSRC is set first. | |
356 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) { | 444 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) { |
357 AddVideoTrack(); | 445 AddVideoTrack(); |
358 rtc::scoped_refptr<VideoRtpSender> sender = | 446 video_rtp_sender_ = new VideoRtpSender(video_channel_); |
359 new VideoRtpSender(&video_provider_); | 447 video_rtp_sender_->SetSsrc(kVideoSsrc); |
360 sender->SetSsrc(kVideoSsrc); | 448 video_rtp_sender_->SetTrack(video_track_); |
361 EXPECT_CALL(video_provider_, | 449 VerifyVideoChannelInput(); |
362 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | 450 |
363 sender->SetTrack(video_track_); | 451 DestroyVideoRtpSender(); |
364 | 452 } |
365 // Calls expected from destructor. | 453 |
366 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | 454 // Test that the media channel is enabled for sending when the video sender |
367 .Times(1); | 455 // has a track and SSRC, when the SSRC is set last. |
368 } | |
369 | |
370 // Test that a video sender calls the expected methods on the provider once | |
371 // it has a track and SSRC, when the SSRC is set last. | |
372 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) { | 456 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) { |
373 AddVideoTrack(); | 457 AddVideoTrack(); |
374 rtc::scoped_refptr<VideoRtpSender> sender = | 458 video_rtp_sender_ = new VideoRtpSender(video_channel_); |
375 new VideoRtpSender(&video_provider_); | 459 video_rtp_sender_->SetTrack(video_track_); |
376 sender->SetTrack(video_track_); | 460 video_rtp_sender_->SetSsrc(kVideoSsrc); |
377 EXPECT_CALL(video_provider_, | 461 VerifyVideoChannelInput(); |
378 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | 462 |
379 sender->SetSsrc(kVideoSsrc); | 463 DestroyVideoRtpSender(); |
380 | 464 } |
381 // Calls expected from destructor. | 465 |
382 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | 466 // Test that the media channel stops sending when the audio sender's SSRC is set |
383 .Times(1); | 467 // to 0. |
384 } | |
385 | |
386 // Test that the sender is disconnected from the provider when its SSRC is | |
387 // set to 0. | |
388 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) { | 468 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) { |
389 rtc::scoped_refptr<AudioTrackInterface> track = | 469 CreateAudioRtpSender(); |
390 AudioTrack::Create(kAudioTrackId, nullptr); | 470 |
391 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 471 audio_rtp_sender_->SetSsrc(0); |
392 rtc::scoped_refptr<AudioRtpSender> sender = | 472 VerifyVoiceChannelNoInput(); |
393 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); | 473 } |
394 sender->SetSsrc(kAudioSsrc); | 474 |
395 | 475 // Test that the media channel stops sending when the video sender's SSRC is set |
396 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); | 476 // to 0. |
397 sender->SetSsrc(0); | |
398 | |
399 // Make sure it's SetSsrc that called methods on the provider, and not the | |
400 // destructor. | |
401 EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0); | |
402 } | |
403 | |
404 // Test that the sender is disconnected from the provider when its SSRC is | |
405 // set to 0. | |
406 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) { | 477 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) { |
407 AddVideoTrack(); | 478 CreateAudioRtpSender(); |
408 EXPECT_CALL(video_provider_, | 479 |
409 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | 480 audio_rtp_sender_->SetSsrc(0); |
410 rtc::scoped_refptr<VideoRtpSender> sender = | 481 VerifyVideoChannelNoInput(); |
411 new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_); | 482 } |
412 sender->SetSsrc(kVideoSsrc); | 483 |
413 | 484 // Test that the media channel stops sending when the audio sender's track is |
414 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | 485 // set to null. |
415 .Times(1); | |
416 sender->SetSsrc(0); | |
417 | |
418 // Make sure it's SetSsrc that called methods on the provider, and not the | |
419 // destructor. | |
420 EXPECT_CALL(video_provider_, SetVideoSend(_, _, _, _)).Times(0); | |
421 } | |
422 | |
423 TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) { | 486 TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) { |
424 rtc::scoped_refptr<AudioTrackInterface> track = | 487 CreateAudioRtpSender(); |
425 AudioTrack::Create(kAudioTrackId, nullptr); | 488 |
426 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 489 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr)); |
427 rtc::scoped_refptr<AudioRtpSender> sender = | 490 VerifyVoiceChannelNoInput(); |
428 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); | 491 } |
429 sender->SetSsrc(kAudioSsrc); | 492 |
430 | 493 // Test that the media channel stops sending when the video sender's track is |
431 // Expect that SetAudioSend will be called before the reference to the track | 494 // set to null. |
432 // is released. | |
433 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, nullptr)) | |
434 .Times(1) | |
435 .WillOnce(InvokeWithoutArgs([&track] { | |
436 EXPECT_LT(2, track->AddRef()); | |
437 track->Release(); | |
438 })); | |
439 EXPECT_TRUE(sender->SetTrack(nullptr)); | |
440 | |
441 // Make sure it's SetTrack that called methods on the provider, and not the | |
442 // destructor. | |
443 EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0); | |
444 } | |
445 | |
446 TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) { | 495 TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) { |
447 rtc::scoped_refptr<VideoTrackSourceInterface> source( | 496 CreateVideoRtpSender(); |
448 FakeVideoTrackSource::Create()); | 497 |
449 rtc::scoped_refptr<VideoTrackInterface> track = | 498 video_rtp_sender_->SetSsrc(0); |
450 VideoTrack::Create(kVideoTrackId, source); | 499 VerifyVideoChannelNoInput(); |
451 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _, track.get())); | 500 } |
452 rtc::scoped_refptr<VideoRtpSender> sender = | 501 |
453 new VideoRtpSender(track, kStreamLabel1, &video_provider_); | 502 // Test that when the audio sender's SSRC is changed, the media channel stops |
454 sender->SetSsrc(kVideoSsrc); | 503 // sending with the old SSRC and starts sending with the new one. |
455 | |
456 // Expect that SetVideoSend will be called before the reference to the track | |
457 // is released. | |
458 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | |
459 .Times(1) | |
460 .WillOnce(InvokeWithoutArgs([&track] { | |
461 EXPECT_LT(2, track->AddRef()); | |
462 track->Release(); | |
463 })); | |
464 EXPECT_TRUE(sender->SetTrack(nullptr)); | |
465 | |
466 // Make sure it's SetTrack that called methods on the provider, and not the | |
467 // destructor. | |
468 EXPECT_CALL(video_provider_, SetVideoSend(_, _, _, _)).Times(0); | |
469 } | |
470 | |
471 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) { | 504 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) { |
472 AddVideoTrack(); | 505 CreateAudioRtpSender(); |
473 rtc::scoped_refptr<AudioTrackInterface> track = | 506 |
474 AudioTrack::Create(kAudioTrackId, nullptr); | 507 audio_rtp_sender_->SetSsrc(kAudioSsrc2); |
475 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 508 VerifyVoiceChannelNoInput(kAudioSsrc); |
476 rtc::scoped_refptr<AudioRtpSender> sender = | 509 VerifyVoiceChannelInput(kAudioSsrc2); |
477 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); | 510 |
478 sender->SetSsrc(kAudioSsrc); | 511 audio_rtp_sender_ = nullptr; |
479 | 512 VerifyVoiceChannelNoInput(kAudioSsrc2); |
480 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); | 513 } |
481 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, true, _, _)).Times(1); | 514 |
482 sender->SetSsrc(kAudioSsrc2); | 515 // Test that when the audio sender's SSRC is changed, the media channel stops |
483 | 516 // sending with the old SSRC and starts sending with the new one. |
484 // Calls expected from destructor. | |
485 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, false, _, _)).Times(1); | |
486 } | |
487 | |
488 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) { | 517 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) { |
489 AddVideoTrack(); | 518 CreateVideoRtpSender(); |
490 EXPECT_CALL(video_provider_, | 519 |
491 SetVideoSend(kVideoSsrc, true, _, video_track_.get())); | 520 video_rtp_sender_->SetSsrc(kVideoSsrc2); |
492 rtc::scoped_refptr<VideoRtpSender> sender = | 521 VerifyVideoChannelNoInput(kVideoSsrc); |
493 new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_); | 522 VerifyVideoChannelInput(kVideoSsrc2); |
494 sender->SetSsrc(kVideoSsrc); | 523 |
495 | 524 video_rtp_sender_ = nullptr; |
496 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _, nullptr)) | 525 VerifyVideoChannelNoInput(kVideoSsrc2); |
497 .Times(1); | |
498 EXPECT_CALL(video_provider_, | |
499 SetVideoSend(kVideoSsrc2, true, _, video_track_.get())) | |
500 .Times(1); | |
501 sender->SetSsrc(kVideoSsrc2); | |
502 | |
503 // Calls expected from destructor. | |
504 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, false, _, nullptr)) | |
505 .Times(1); | |
506 } | 526 } |
507 | 527 |
508 TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) { | 528 TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) { |
509 CreateAudioRtpSender(); | 529 CreateAudioRtpSender(); |
510 | 530 |
511 EXPECT_CALL(audio_provider_, GetAudioRtpSendParameters(kAudioSsrc)) | |
512 .WillOnce(Return(RtpParameters())); | |
513 EXPECT_CALL(audio_provider_, SetAudioRtpSendParameters(kAudioSsrc, _)) | |
514 .WillOnce(Return(true)); | |
515 RtpParameters params = audio_rtp_sender_->GetParameters(); | 531 RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 532 EXPECT_EQ(1u, params.encodings.size()); |
516 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params)); | 533 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params)); |
517 | 534 |
518 DestroyAudioRtpSender(); | 535 DestroyAudioRtpSender(); |
519 } | 536 } |
520 | 537 |
| 538 TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) { |
| 539 CreateAudioRtpSender(); |
| 540 |
| 541 EXPECT_EQ(-1, voice_media_channel_->max_bps()); |
| 542 webrtc::RtpParameters params = audio_rtp_sender_->GetParameters(); |
| 543 EXPECT_EQ(1, params.encodings.size()); |
| 544 EXPECT_EQ(-1, params.encodings[0].max_bitrate_bps); |
| 545 params.encodings[0].max_bitrate_bps = 1000; |
| 546 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params)); |
| 547 |
| 548 // Read back the parameters and verify they have been changed. |
| 549 params = audio_rtp_sender_->GetParameters(); |
| 550 EXPECT_EQ(1, params.encodings.size()); |
| 551 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
| 552 |
| 553 // Verify that the audio channel received the new parameters. |
| 554 params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc); |
| 555 EXPECT_EQ(1, params.encodings.size()); |
| 556 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
| 557 |
| 558 // Verify that the global bitrate limit has not been changed. |
| 559 EXPECT_EQ(-1, voice_media_channel_->max_bps()); |
| 560 |
| 561 DestroyAudioRtpSender(); |
| 562 } |
| 563 |
521 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) { | 564 TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) { |
522 CreateVideoRtpSender(); | 565 CreateVideoRtpSender(); |
523 | 566 |
524 EXPECT_CALL(video_provider_, GetVideoRtpSendParameters(kVideoSsrc)) | |
525 .WillOnce(Return(RtpParameters())); | |
526 EXPECT_CALL(video_provider_, SetVideoRtpSendParameters(kVideoSsrc, _)) | |
527 .WillOnce(Return(true)); | |
528 RtpParameters params = video_rtp_sender_->GetParameters(); | 567 RtpParameters params = video_rtp_sender_->GetParameters(); |
| 568 EXPECT_EQ(1u, params.encodings.size()); |
529 EXPECT_TRUE(video_rtp_sender_->SetParameters(params)); | 569 EXPECT_TRUE(video_rtp_sender_->SetParameters(params)); |
530 | 570 |
531 DestroyVideoRtpSender(); | 571 DestroyVideoRtpSender(); |
532 } | 572 } |
533 | 573 |
| 574 TEST_F(RtpSenderReceiverTest, SetVideoMaxSendBitrate) { |
| 575 CreateVideoRtpSender(); |
| 576 |
| 577 EXPECT_EQ(-1, video_media_channel_->max_bps()); |
| 578 webrtc::RtpParameters params = video_rtp_sender_->GetParameters(); |
| 579 EXPECT_EQ(1, params.encodings.size()); |
| 580 EXPECT_EQ(-1, params.encodings[0].max_bitrate_bps); |
| 581 params.encodings[0].max_bitrate_bps = 1000; |
| 582 EXPECT_TRUE(video_rtp_sender_->SetParameters(params)); |
| 583 |
| 584 // Read back the parameters and verify they have been changed. |
| 585 params = video_rtp_sender_->GetParameters(); |
| 586 EXPECT_EQ(1, params.encodings.size()); |
| 587 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
| 588 |
| 589 // Verify that the video channel received the new parameters. |
| 590 params = video_media_channel_->GetRtpSendParameters(kVideoSsrc); |
| 591 EXPECT_EQ(1, params.encodings.size()); |
| 592 EXPECT_EQ(1000, params.encodings[0].max_bitrate_bps); |
| 593 |
| 594 // Verify that the global bitrate limit has not been changed. |
| 595 EXPECT_EQ(-1, video_media_channel_->max_bps()); |
| 596 |
| 597 DestroyVideoRtpSender(); |
| 598 } |
| 599 |
534 TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) { | 600 TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) { |
535 CreateAudioRtpReceiver(); | 601 CreateAudioRtpReceiver(); |
536 | 602 |
537 EXPECT_CALL(audio_provider_, GetAudioRtpReceiveParameters(kAudioSsrc)) | |
538 .WillOnce(Return(RtpParameters())); | |
539 EXPECT_CALL(audio_provider_, SetAudioRtpReceiveParameters(kAudioSsrc, _)) | |
540 .WillOnce(Return(true)); | |
541 RtpParameters params = audio_rtp_receiver_->GetParameters(); | 603 RtpParameters params = audio_rtp_receiver_->GetParameters(); |
| 604 EXPECT_EQ(1u, params.encodings.size()); |
542 EXPECT_TRUE(audio_rtp_receiver_->SetParameters(params)); | 605 EXPECT_TRUE(audio_rtp_receiver_->SetParameters(params)); |
543 | 606 |
544 DestroyAudioRtpReceiver(); | 607 DestroyAudioRtpReceiver(); |
545 } | 608 } |
546 | 609 |
547 TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetParameters) { | 610 TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetParameters) { |
548 CreateVideoRtpReceiver(); | 611 CreateVideoRtpReceiver(); |
549 | 612 |
550 EXPECT_CALL(video_provider_, GetVideoRtpReceiveParameters(kVideoSsrc)) | |
551 .WillOnce(Return(RtpParameters())); | |
552 EXPECT_CALL(video_provider_, SetVideoRtpReceiveParameters(kVideoSsrc, _)) | |
553 .WillOnce(Return(true)); | |
554 RtpParameters params = video_rtp_receiver_->GetParameters(); | 613 RtpParameters params = video_rtp_receiver_->GetParameters(); |
| 614 EXPECT_EQ(1u, params.encodings.size()); |
555 EXPECT_TRUE(video_rtp_receiver_->SetParameters(params)); | 615 EXPECT_TRUE(video_rtp_receiver_->SetParameters(params)); |
556 | 616 |
557 DestroyVideoRtpReceiver(); | 617 DestroyVideoRtpReceiver(); |
558 } | 618 } |
559 | 619 |
560 } // namespace webrtc | 620 } // namespace webrtc |
OLD | NEW |