solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 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 |
| 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. |
| 9 | */ |
| 10 | |
| 11 | #include <list> |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 12 | #include <map> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 13 | #include <memory> |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 14 | #include <utility> |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 15 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 16 | #include "api/test/mock_audio_mixer.h" |
| 17 | #include "call/audio_state.h" |
| 18 | #include "call/call.h" |
| 19 | #include "call/fake_rtp_transport_controller_send.h" |
| 20 | #include "logging/rtc_event_log/rtc_event_log.h" |
| 21 | #include "modules/audio_device/include/mock_audio_device.h" |
| 22 | #include "modules/audio_mixer/audio_mixer_impl.h" |
| 23 | #include "modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h" |
| 24 | #include "modules/pacing/mock/mock_paced_sender.h" |
| 25 | #include "modules/rtp_rtcp/include/rtp_rtcp.h" |
| 26 | #include "rtc_base/ptr_util.h" |
| 27 | #include "test/fake_encoder.h" |
| 28 | #include "test/gtest.h" |
| 29 | #include "test/mock_audio_decoder_factory.h" |
| 30 | #include "test/mock_transport.h" |
| 31 | #include "test/mock_voice_engine.h" |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 32 | |
| 33 | namespace { |
| 34 | |
| 35 | struct CallHelper { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 36 | explicit CallHelper( |
| 37 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory = nullptr) |
| 38 | : voice_engine_(decoder_factory) { |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 39 | webrtc::AudioState::Config audio_state_config; |
| 40 | audio_state_config.voice_engine = &voice_engine_; |
aleloi | 10111bc | 2016-11-17 06:48:48 -0800 | [diff] [blame] | 41 | audio_state_config.audio_mixer = webrtc::AudioMixerImpl::Create(); |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 42 | audio_state_config.audio_processing = webrtc::AudioProcessing::Create(); |
aleloi | dd31071 | 2016-11-17 06:28:59 -0800 | [diff] [blame] | 43 | EXPECT_CALL(voice_engine_, audio_device_module()); |
aleloi | dd31071 | 2016-11-17 06:28:59 -0800 | [diff] [blame] | 44 | EXPECT_CALL(voice_engine_, audio_transport()); |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 45 | webrtc::Call::Config config(&event_log_); |
solenberg | 566ef24 | 2015-11-06 15:34:49 -0800 | [diff] [blame] | 46 | config.audio_state = webrtc::AudioState::Create(audio_state_config); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 47 | call_.reset(webrtc::Call::Create(config)); |
| 48 | } |
| 49 | |
| 50 | webrtc::Call* operator->() { return call_.get(); } |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 51 | webrtc::test::MockVoiceEngine* voice_engine() { return &voice_engine_; } |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 52 | |
| 53 | private: |
solenberg | 3a94154 | 2015-11-16 07:34:50 -0800 | [diff] [blame] | 54 | testing::NiceMock<webrtc::test::MockVoiceEngine> voice_engine_; |
skvlad | 11a9cbf | 2016-10-07 11:53:05 -0700 | [diff] [blame] | 55 | webrtc::RtcEventLogNullImpl event_log_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 56 | std::unique_ptr<webrtc::Call> call_; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 57 | }; |
| 58 | } // namespace |
| 59 | |
| 60 | namespace webrtc { |
| 61 | |
| 62 | TEST(CallTest, ConstructDestruct) { |
| 63 | CallHelper call; |
| 64 | } |
| 65 | |
| 66 | TEST(CallTest, CreateDestroy_AudioSendStream) { |
| 67 | CallHelper call; |
| 68 | AudioSendStream::Config config(nullptr); |
| 69 | config.rtp.ssrc = 42; |
| 70 | config.voe_channel_id = 123; |
| 71 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 72 | EXPECT_NE(stream, nullptr); |
| 73 | call->DestroyAudioSendStream(stream); |
| 74 | } |
| 75 | |
| 76 | TEST(CallTest, CreateDestroy_AudioReceiveStream) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 77 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory( |
| 78 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>); |
| 79 | CallHelper call(decoder_factory); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 80 | AudioReceiveStream::Config config; |
| 81 | config.rtp.remote_ssrc = 42; |
| 82 | config.voe_channel_id = 123; |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 83 | config.decoder_factory = decoder_factory; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 84 | AudioReceiveStream* stream = call->CreateAudioReceiveStream(config); |
| 85 | EXPECT_NE(stream, nullptr); |
| 86 | call->DestroyAudioReceiveStream(stream); |
| 87 | } |
| 88 | |
| 89 | TEST(CallTest, CreateDestroy_AudioSendStreams) { |
| 90 | CallHelper call; |
| 91 | AudioSendStream::Config config(nullptr); |
| 92 | config.voe_channel_id = 123; |
| 93 | std::list<AudioSendStream*> streams; |
| 94 | for (int i = 0; i < 2; ++i) { |
| 95 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 96 | config.rtp.ssrc = ssrc; |
| 97 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 98 | EXPECT_NE(stream, nullptr); |
| 99 | if (ssrc & 1) { |
| 100 | streams.push_back(stream); |
| 101 | } else { |
| 102 | streams.push_front(stream); |
| 103 | } |
| 104 | } |
| 105 | for (auto s : streams) { |
| 106 | call->DestroyAudioSendStream(s); |
| 107 | } |
| 108 | streams.clear(); |
| 109 | } |
| 110 | } |
| 111 | |
| 112 | TEST(CallTest, CreateDestroy_AudioReceiveStreams) { |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 113 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory( |
| 114 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>); |
| 115 | CallHelper call(decoder_factory); |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 116 | AudioReceiveStream::Config config; |
| 117 | config.voe_channel_id = 123; |
ossu | 29b1a8d | 2016-06-13 07:34:51 -0700 | [diff] [blame] | 118 | config.decoder_factory = decoder_factory; |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 119 | std::list<AudioReceiveStream*> streams; |
| 120 | for (int i = 0; i < 2; ++i) { |
| 121 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
| 122 | config.rtp.remote_ssrc = ssrc; |
| 123 | AudioReceiveStream* stream = call->CreateAudioReceiveStream(config); |
| 124 | EXPECT_NE(stream, nullptr); |
| 125 | if (ssrc & 1) { |
| 126 | streams.push_back(stream); |
| 127 | } else { |
| 128 | streams.push_front(stream); |
| 129 | } |
| 130 | } |
| 131 | for (auto s : streams) { |
| 132 | call->DestroyAudioReceiveStream(s); |
| 133 | } |
| 134 | streams.clear(); |
| 135 | } |
| 136 | } |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 137 | |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 138 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_RecvFirst) { |
| 139 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory( |
| 140 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>); |
| 141 | CallHelper call(decoder_factory); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 142 | ::testing::NiceMock<MockRtpRtcp> mock_rtp_rtcp; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 143 | |
| 144 | constexpr int kRecvChannelId = 101; |
| 145 | |
| 146 | // Set up the mock to create a channel proxy which we know of, so that we can |
| 147 | // add our expectations to it. |
| 148 | test::MockVoEChannelProxy* recv_channel_proxy = nullptr; |
| 149 | EXPECT_CALL(*call.voice_engine(), ChannelProxyFactory(testing::_)) |
| 150 | .WillRepeatedly(testing::Invoke([&](int channel_id) { |
| 151 | test::MockVoEChannelProxy* channel_proxy = |
| 152 | new testing::NiceMock<test::MockVoEChannelProxy>(); |
| 153 | EXPECT_CALL(*channel_proxy, GetAudioDecoderFactory()) |
| 154 | .WillRepeatedly(testing::ReturnRef(decoder_factory)); |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 155 | EXPECT_CALL(*channel_proxy, SetReceiveCodecs(testing::_)) |
| 156 | .WillRepeatedly(testing::Invoke( |
| 157 | [](const std::map<int, SdpAudioFormat>& codecs) { |
| 158 | EXPECT_THAT(codecs, testing::IsEmpty()); |
| 159 | })); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 160 | EXPECT_CALL(*channel_proxy, GetRtpRtcp(testing::_, testing::_)) |
| 161 | .WillRepeatedly(testing::SetArgPointee<0>(&mock_rtp_rtcp)); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 162 | // If being called for the send channel, save a pointer to the channel |
| 163 | // proxy for later. |
| 164 | if (channel_id == kRecvChannelId) { |
| 165 | EXPECT_FALSE(recv_channel_proxy); |
| 166 | recv_channel_proxy = channel_proxy; |
| 167 | } |
| 168 | return channel_proxy; |
| 169 | })); |
| 170 | |
| 171 | AudioReceiveStream::Config recv_config; |
| 172 | recv_config.rtp.remote_ssrc = 42; |
| 173 | recv_config.rtp.local_ssrc = 777; |
| 174 | recv_config.voe_channel_id = kRecvChannelId; |
| 175 | recv_config.decoder_factory = decoder_factory; |
| 176 | AudioReceiveStream* recv_stream = call->CreateAudioReceiveStream(recv_config); |
| 177 | EXPECT_NE(recv_stream, nullptr); |
| 178 | |
| 179 | EXPECT_CALL(*recv_channel_proxy, AssociateSendChannel(testing::_)).Times(1); |
| 180 | AudioSendStream::Config send_config(nullptr); |
| 181 | send_config.rtp.ssrc = 777; |
| 182 | send_config.voe_channel_id = 123; |
| 183 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 184 | EXPECT_NE(send_stream, nullptr); |
| 185 | |
| 186 | EXPECT_CALL(*recv_channel_proxy, DisassociateSendChannel()).Times(1); |
| 187 | call->DestroyAudioSendStream(send_stream); |
| 188 | |
| 189 | EXPECT_CALL(*recv_channel_proxy, DisassociateSendChannel()).Times(1); |
| 190 | call->DestroyAudioReceiveStream(recv_stream); |
| 191 | } |
| 192 | |
| 193 | TEST(CallTest, CreateDestroy_AssociateAudioSendReceiveStreams_SendFirst) { |
| 194 | rtc::scoped_refptr<webrtc::AudioDecoderFactory> decoder_factory( |
| 195 | new rtc::RefCountedObject<webrtc::MockAudioDecoderFactory>); |
| 196 | CallHelper call(decoder_factory); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 197 | ::testing::NiceMock<MockRtpRtcp> mock_rtp_rtcp; |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 198 | |
| 199 | constexpr int kRecvChannelId = 101; |
| 200 | |
| 201 | // Set up the mock to create a channel proxy which we know of, so that we can |
| 202 | // add our expectations to it. |
| 203 | test::MockVoEChannelProxy* recv_channel_proxy = nullptr; |
| 204 | EXPECT_CALL(*call.voice_engine(), ChannelProxyFactory(testing::_)) |
| 205 | .WillRepeatedly(testing::Invoke([&](int channel_id) { |
| 206 | test::MockVoEChannelProxy* channel_proxy = |
| 207 | new testing::NiceMock<test::MockVoEChannelProxy>(); |
| 208 | EXPECT_CALL(*channel_proxy, GetAudioDecoderFactory()) |
| 209 | .WillRepeatedly(testing::ReturnRef(decoder_factory)); |
kwiberg | 1c07c70 | 2017-03-27 07:15:49 -0700 | [diff] [blame] | 210 | EXPECT_CALL(*channel_proxy, SetReceiveCodecs(testing::_)) |
| 211 | .WillRepeatedly(testing::Invoke( |
| 212 | [](const std::map<int, SdpAudioFormat>& codecs) { |
| 213 | EXPECT_THAT(codecs, testing::IsEmpty()); |
| 214 | })); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 215 | EXPECT_CALL(*channel_proxy, GetRtpRtcp(testing::_, testing::_)) |
| 216 | .WillRepeatedly(testing::SetArgPointee<0>(&mock_rtp_rtcp)); |
solenberg | 7602aab | 2016-11-14 11:30:07 -0800 | [diff] [blame] | 217 | // If being called for the send channel, save a pointer to the channel |
| 218 | // proxy for later. |
| 219 | if (channel_id == kRecvChannelId) { |
| 220 | EXPECT_FALSE(recv_channel_proxy); |
| 221 | recv_channel_proxy = channel_proxy; |
| 222 | // We need to set this expectation here since the channel proxy is |
| 223 | // created as a side effect of CreateAudioReceiveStream(). |
| 224 | EXPECT_CALL(*recv_channel_proxy, |
| 225 | AssociateSendChannel(testing::_)).Times(1); |
| 226 | } |
| 227 | return channel_proxy; |
| 228 | })); |
| 229 | |
| 230 | AudioSendStream::Config send_config(nullptr); |
| 231 | send_config.rtp.ssrc = 777; |
| 232 | send_config.voe_channel_id = 123; |
| 233 | AudioSendStream* send_stream = call->CreateAudioSendStream(send_config); |
| 234 | EXPECT_NE(send_stream, nullptr); |
| 235 | |
| 236 | AudioReceiveStream::Config recv_config; |
| 237 | recv_config.rtp.remote_ssrc = 42; |
| 238 | recv_config.rtp.local_ssrc = 777; |
| 239 | recv_config.voe_channel_id = kRecvChannelId; |
| 240 | recv_config.decoder_factory = decoder_factory; |
| 241 | AudioReceiveStream* recv_stream = call->CreateAudioReceiveStream(recv_config); |
| 242 | EXPECT_NE(recv_stream, nullptr); |
| 243 | |
| 244 | EXPECT_CALL(*recv_channel_proxy, DisassociateSendChannel()).Times(1); |
| 245 | call->DestroyAudioReceiveStream(recv_stream); |
| 246 | |
| 247 | call->DestroyAudioSendStream(send_stream); |
| 248 | } |
| 249 | |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 250 | TEST(CallTest, CreateDestroy_FlexfecReceiveStream) { |
| 251 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 252 | MockTransport rtcp_send_transport; |
| 253 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 254 | config.payload_type = 118; |
| 255 | config.remote_ssrc = 38837212; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 256 | config.protected_media_ssrcs = {27273}; |
| 257 | |
| 258 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 259 | EXPECT_NE(stream, nullptr); |
| 260 | call->DestroyFlexfecReceiveStream(stream); |
| 261 | } |
| 262 | |
| 263 | TEST(CallTest, CreateDestroy_FlexfecReceiveStreams) { |
| 264 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 265 | MockTransport rtcp_send_transport; |
| 266 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 267 | config.payload_type = 118; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 268 | std::list<FlexfecReceiveStream*> streams; |
| 269 | |
| 270 | for (int i = 0; i < 2; ++i) { |
| 271 | for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 272 | config.remote_ssrc = ssrc; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 273 | config.protected_media_ssrcs = {ssrc + 1}; |
| 274 | FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); |
| 275 | EXPECT_NE(stream, nullptr); |
| 276 | if (ssrc & 1) { |
| 277 | streams.push_back(stream); |
| 278 | } else { |
| 279 | streams.push_front(stream); |
| 280 | } |
| 281 | } |
| 282 | for (auto s : streams) { |
| 283 | call->DestroyFlexfecReceiveStream(s); |
| 284 | } |
| 285 | streams.clear(); |
| 286 | } |
| 287 | } |
| 288 | |
| 289 | TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) { |
| 290 | CallHelper call; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 291 | MockTransport rtcp_send_transport; |
| 292 | FlexfecReceiveStream::Config config(&rtcp_send_transport); |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 293 | config.payload_type = 118; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 294 | config.protected_media_ssrcs = {1324234}; |
| 295 | FlexfecReceiveStream* stream; |
| 296 | std::list<FlexfecReceiveStream*> streams; |
| 297 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 298 | config.remote_ssrc = 838383; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 299 | stream = call->CreateFlexfecReceiveStream(config); |
| 300 | EXPECT_NE(stream, nullptr); |
| 301 | streams.push_back(stream); |
| 302 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 303 | config.remote_ssrc = 424993; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 304 | stream = call->CreateFlexfecReceiveStream(config); |
| 305 | EXPECT_NE(stream, nullptr); |
| 306 | streams.push_back(stream); |
| 307 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 308 | config.remote_ssrc = 99383; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 309 | stream = call->CreateFlexfecReceiveStream(config); |
| 310 | EXPECT_NE(stream, nullptr); |
| 311 | streams.push_back(stream); |
| 312 | |
brandtr | 1cfbd60 | 2016-12-08 04:17:53 -0800 | [diff] [blame] | 313 | config.remote_ssrc = 5548; |
brandtr | 25445d3 | 2016-10-23 23:37:14 -0700 | [diff] [blame] | 314 | stream = call->CreateFlexfecReceiveStream(config); |
| 315 | EXPECT_NE(stream, nullptr); |
| 316 | streams.push_back(stream); |
| 317 | |
| 318 | for (auto s : streams) { |
| 319 | call->DestroyFlexfecReceiveStream(s); |
| 320 | } |
| 321 | } |
| 322 | |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 323 | namespace { |
| 324 | struct CallBitrateHelper { |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 325 | CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {} |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 326 | |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 327 | explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config) |
Stefan Holmer | 5c8942a | 2017-08-22 16:16:44 +0200 | [diff] [blame] | 328 | : mock_cc_(Clock::GetRealTimeClock(), &event_log_, &pacer_) { |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 329 | Call::Config config(&event_log_); |
| 330 | config.bitrate_config = bitrate_config; |
| 331 | call_.reset( |
| 332 | Call::Create(config, rtc::MakeUnique<FakeRtpTransportControllerSend>( |
Stefan Holmer | 5c8942a | 2017-08-22 16:16:44 +0200 | [diff] [blame] | 333 | &packet_router_, &pacer_, &mock_cc_))); |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 334 | } |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 335 | |
| 336 | webrtc::Call* operator->() { return call_.get(); } |
| 337 | testing::NiceMock<test::MockSendSideCongestionController>& mock_cc() { |
| 338 | return mock_cc_; |
| 339 | } |
| 340 | |
| 341 | private: |
| 342 | webrtc::RtcEventLogNullImpl event_log_; |
| 343 | PacketRouter packet_router_; |
Stefan Holmer | 5c8942a | 2017-08-22 16:16:44 +0200 | [diff] [blame] | 344 | testing::NiceMock<MockPacedSender> pacer_; |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 345 | testing::NiceMock<test::MockSendSideCongestionController> mock_cc_; |
| 346 | std::unique_ptr<Call> call_; |
| 347 | }; |
| 348 | } // namespace |
| 349 | |
| 350 | TEST(CallBitrateTest, SetBitrateConfigWithValidConfigCallsSetBweBitrates) { |
| 351 | CallBitrateHelper call; |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 352 | |
| 353 | Call::Config::BitrateConfig bitrate_config; |
| 354 | bitrate_config.min_bitrate_bps = 1; |
| 355 | bitrate_config.start_bitrate_bps = 2; |
| 356 | bitrate_config.max_bitrate_bps = 3; |
| 357 | |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 358 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1, 2, 3)); |
| 359 | call->SetBitrateConfig(bitrate_config); |
| 360 | } |
| 361 | |
| 362 | TEST(CallBitrateTest, SetBitrateConfigWithDifferentMinCallsSetBweBitrates) { |
| 363 | CallBitrateHelper call; |
| 364 | |
| 365 | Call::Config::BitrateConfig bitrate_config; |
| 366 | bitrate_config.min_bitrate_bps = 10; |
| 367 | bitrate_config.start_bitrate_bps = 20; |
| 368 | bitrate_config.max_bitrate_bps = 30; |
| 369 | call->SetBitrateConfig(bitrate_config); |
| 370 | |
| 371 | bitrate_config.min_bitrate_bps = 11; |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 372 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(11, -1, 30)); |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 373 | call->SetBitrateConfig(bitrate_config); |
| 374 | } |
| 375 | |
| 376 | TEST(CallBitrateTest, SetBitrateConfigWithDifferentStartCallsSetBweBitrates) { |
| 377 | CallBitrateHelper call; |
| 378 | |
| 379 | Call::Config::BitrateConfig bitrate_config; |
| 380 | bitrate_config.min_bitrate_bps = 10; |
| 381 | bitrate_config.start_bitrate_bps = 20; |
| 382 | bitrate_config.max_bitrate_bps = 30; |
| 383 | call->SetBitrateConfig(bitrate_config); |
| 384 | |
| 385 | bitrate_config.start_bitrate_bps = 21; |
| 386 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(10, 21, 30)); |
| 387 | call->SetBitrateConfig(bitrate_config); |
| 388 | } |
| 389 | |
| 390 | TEST(CallBitrateTest, SetBitrateConfigWithDifferentMaxCallsSetBweBitrates) { |
| 391 | CallBitrateHelper call; |
| 392 | |
| 393 | Call::Config::BitrateConfig bitrate_config; |
| 394 | bitrate_config.min_bitrate_bps = 10; |
| 395 | bitrate_config.start_bitrate_bps = 20; |
| 396 | bitrate_config.max_bitrate_bps = 30; |
| 397 | call->SetBitrateConfig(bitrate_config); |
| 398 | |
| 399 | bitrate_config.max_bitrate_bps = 31; |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 400 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(10, -1, 31)); |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 401 | call->SetBitrateConfig(bitrate_config); |
| 402 | } |
| 403 | |
| 404 | TEST(CallBitrateTest, SetBitrateConfigWithSameConfigElidesSecondCall) { |
| 405 | CallBitrateHelper call; |
zstein | 8c96a14 | 2017-05-17 11:49:12 -0700 | [diff] [blame] | 406 | Call::Config::BitrateConfig bitrate_config; |
| 407 | bitrate_config.min_bitrate_bps = 1; |
| 408 | bitrate_config.start_bitrate_bps = 2; |
| 409 | bitrate_config.max_bitrate_bps = 3; |
| 410 | |
| 411 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1, 2, 3)).Times(1); |
| 412 | call->SetBitrateConfig(bitrate_config); |
| 413 | call->SetBitrateConfig(bitrate_config); |
| 414 | } |
| 415 | |
| 416 | TEST(CallBitrateTest, |
| 417 | SetBitrateConfigWithSameMinMaxAndNegativeStartElidesSecondCall) { |
| 418 | CallBitrateHelper call; |
| 419 | |
| 420 | Call::Config::BitrateConfig bitrate_config; |
| 421 | bitrate_config.min_bitrate_bps = 1; |
| 422 | bitrate_config.start_bitrate_bps = 2; |
| 423 | bitrate_config.max_bitrate_bps = 3; |
| 424 | |
| 425 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1, 2, 3)).Times(1); |
| 426 | call->SetBitrateConfig(bitrate_config); |
| 427 | |
| 428 | bitrate_config.start_bitrate_bps = -1; |
zstein | 7cb69d5 | 2017-05-08 11:52:38 -0700 | [diff] [blame] | 429 | call->SetBitrateConfig(bitrate_config); |
| 430 | } |
| 431 | |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 432 | TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) { |
| 433 | constexpr uint32_t kSSRC = 12345; |
| 434 | testing::NiceMock<test::MockAudioDeviceModule> mock_adm; |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 435 | rtc::scoped_refptr<test::MockAudioMixer> mock_mixer( |
| 436 | new rtc::RefCountedObject<test::MockAudioMixer>); |
| 437 | |
| 438 | // There's similar functionality in cricket::VoEWrapper but it's not reachable |
| 439 | // from here. Since we're working on removing VoE interfaces, I doubt it's |
| 440 | // worth making VoEWrapper more easily available. |
| 441 | struct ScopedVoiceEngine { |
| 442 | ScopedVoiceEngine() |
| 443 | : voe(VoiceEngine::Create()), |
| 444 | base(VoEBase::GetInterface(voe)) {} |
| 445 | ~ScopedVoiceEngine() { |
| 446 | base->Release(); |
| 447 | EXPECT_TRUE(VoiceEngine::Delete(voe)); |
| 448 | } |
| 449 | |
| 450 | VoiceEngine* voe; |
| 451 | VoEBase* base; |
| 452 | }; |
| 453 | ScopedVoiceEngine voice_engine; |
| 454 | |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 455 | AudioState::Config audio_state_config; |
| 456 | audio_state_config.voice_engine = voice_engine.voe; |
| 457 | audio_state_config.audio_mixer = mock_mixer; |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 458 | audio_state_config.audio_processing = AudioProcessing::Create(); |
| 459 | voice_engine.base->Init(&mock_adm, audio_state_config.audio_processing.get()); |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 460 | auto audio_state = AudioState::Create(audio_state_config); |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 461 | |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 462 | RtcEventLogNullImpl event_log; |
| 463 | Call::Config call_config(&event_log); |
| 464 | call_config.audio_state = audio_state; |
| 465 | std::unique_ptr<Call> call(Call::Create(call_config)); |
| 466 | |
| 467 | auto create_stream_and_get_rtp_state = [&](uint32_t ssrc) { |
| 468 | AudioSendStream::Config config(nullptr); |
| 469 | config.rtp.ssrc = ssrc; |
| 470 | config.voe_channel_id = voice_engine.base->CreateChannel(); |
| 471 | AudioSendStream* stream = call->CreateAudioSendStream(config); |
| 472 | VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine.voe); |
| 473 | auto channel_proxy = voe_impl->GetChannelProxy(config.voe_channel_id); |
| 474 | RtpRtcp* rtp_rtcp = nullptr; |
| 475 | RtpReceiver* rtp_receiver = nullptr; // Unused but required for call. |
| 476 | channel_proxy->GetRtpRtcp(&rtp_rtcp, &rtp_receiver); |
| 477 | const RtpState rtp_state = rtp_rtcp->GetRtpState(); |
| 478 | call->DestroyAudioSendStream(stream); |
| 479 | voice_engine.base->DeleteChannel(config.voe_channel_id); |
| 480 | return rtp_state; |
| 481 | }; |
| 482 | |
| 483 | const RtpState rtp_state1 = create_stream_and_get_rtp_state(kSSRC); |
| 484 | const RtpState rtp_state2 = create_stream_and_get_rtp_state(kSSRC); |
| 485 | |
| 486 | EXPECT_EQ(rtp_state1.sequence_number, rtp_state2.sequence_number); |
| 487 | EXPECT_EQ(rtp_state1.start_timestamp, rtp_state2.start_timestamp); |
| 488 | EXPECT_EQ(rtp_state1.timestamp, rtp_state2.timestamp); |
| 489 | EXPECT_EQ(rtp_state1.capture_time_ms, rtp_state2.capture_time_ms); |
| 490 | EXPECT_EQ(rtp_state1.last_timestamp_time_ms, |
| 491 | rtp_state2.last_timestamp_time_ms); |
| 492 | EXPECT_EQ(rtp_state1.media_has_been_sent, rtp_state2.media_has_been_sent); |
| 493 | } |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 494 | TEST(CallBitrateTest, BiggerMaskMinUsed) { |
| 495 | CallBitrateHelper call; |
| 496 | Call::Config::BitrateConfigMask mask; |
| 497 | mask.min_bitrate_bps = rtc::Optional<int>(1234); |
| 498 | |
| 499 | EXPECT_CALL(call.mock_cc(), |
| 500 | SetBweBitrates(*mask.min_bitrate_bps, testing::_, testing::_)); |
| 501 | call->SetBitrateConfigMask(mask); |
| 502 | } |
| 503 | |
| 504 | TEST(CallBitrateTest, BiggerConfigMinUsed) { |
| 505 | CallBitrateHelper call; |
| 506 | Call::Config::BitrateConfigMask mask; |
| 507 | mask.min_bitrate_bps = rtc::Optional<int>(1000); |
| 508 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, testing::_)); |
| 509 | call->SetBitrateConfigMask(mask); |
| 510 | |
| 511 | Call::Config::BitrateConfig config; |
| 512 | config.min_bitrate_bps = 1234; |
| 513 | |
| 514 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1234, testing::_, testing::_)); |
| 515 | call->SetBitrateConfig(config); |
| 516 | } |
| 517 | |
| 518 | // The last call to set start should be used. |
| 519 | TEST(CallBitrateTest, LatestStartMaskPreferred) { |
| 520 | CallBitrateHelper call; |
| 521 | Call::Config::BitrateConfigMask mask; |
| 522 | mask.start_bitrate_bps = rtc::Optional<int>(1300); |
| 523 | |
| 524 | EXPECT_CALL(call.mock_cc(), |
| 525 | SetBweBitrates(testing::_, *mask.start_bitrate_bps, testing::_)); |
| 526 | call->SetBitrateConfigMask(mask); |
| 527 | |
| 528 | Call::Config::BitrateConfig bitrate_config; |
| 529 | bitrate_config.start_bitrate_bps = 1200; |
| 530 | |
| 531 | EXPECT_CALL( |
| 532 | call.mock_cc(), |
| 533 | SetBweBitrates(testing::_, bitrate_config.start_bitrate_bps, testing::_)); |
| 534 | call->SetBitrateConfig(bitrate_config); |
| 535 | } |
| 536 | |
| 537 | TEST(CallBitrateTest, SmallerMaskMaxUsed) { |
| 538 | Call::Config::BitrateConfig bitrate_config; |
| 539 | bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 2000; |
| 540 | CallBitrateHelper call(bitrate_config); |
| 541 | |
| 542 | Call::Config::BitrateConfigMask mask; |
| 543 | mask.max_bitrate_bps = |
| 544 | rtc::Optional<int>(bitrate_config.start_bitrate_bps + 1000); |
| 545 | |
| 546 | EXPECT_CALL(call.mock_cc(), |
| 547 | SetBweBitrates(testing::_, testing::_, *mask.max_bitrate_bps)); |
| 548 | call->SetBitrateConfigMask(mask); |
| 549 | } |
| 550 | |
| 551 | TEST(CallBitrateTest, SmallerConfigMaxUsed) { |
| 552 | Call::Config::BitrateConfig bitrate_config; |
| 553 | bitrate_config.max_bitrate_bps = bitrate_config.start_bitrate_bps + 1000; |
| 554 | CallBitrateHelper call(bitrate_config); |
| 555 | |
| 556 | Call::Config::BitrateConfigMask mask; |
| 557 | mask.max_bitrate_bps = |
| 558 | rtc::Optional<int>(bitrate_config.start_bitrate_bps + 2000); |
| 559 | |
| 560 | // Expect no calls because nothing changes |
| 561 | EXPECT_CALL(call.mock_cc(), |
| 562 | SetBweBitrates(testing::_, testing::_, testing::_)) |
| 563 | .Times(0); |
| 564 | call->SetBitrateConfigMask(mask); |
| 565 | } |
| 566 | |
| 567 | TEST(CallBitrateTest, MaskStartLessThanConfigMinClamped) { |
| 568 | Call::Config::BitrateConfig bitrate_config; |
| 569 | bitrate_config.min_bitrate_bps = 2000; |
| 570 | CallBitrateHelper call(bitrate_config); |
| 571 | |
| 572 | Call::Config::BitrateConfigMask mask; |
| 573 | mask.start_bitrate_bps = rtc::Optional<int>(1000); |
| 574 | |
| 575 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(2000, 2000, testing::_)); |
| 576 | call->SetBitrateConfigMask(mask); |
| 577 | } |
| 578 | |
| 579 | TEST(CallBitrateTest, MaskStartGreaterThanConfigMaxClamped) { |
| 580 | Call::Config::BitrateConfig bitrate_config; |
| 581 | bitrate_config.start_bitrate_bps = 2000; |
| 582 | CallBitrateHelper call(bitrate_config); |
| 583 | |
| 584 | Call::Config::BitrateConfigMask mask; |
| 585 | mask.max_bitrate_bps = rtc::Optional<int>(1000); |
| 586 | |
| 587 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, -1, 1000)); |
| 588 | call->SetBitrateConfigMask(mask); |
| 589 | } |
| 590 | |
| 591 | TEST(CallBitrateTest, MaskMinGreaterThanConfigMaxClamped) { |
| 592 | Call::Config::BitrateConfig bitrate_config; |
| 593 | bitrate_config.min_bitrate_bps = 2000; |
| 594 | CallBitrateHelper call(bitrate_config); |
| 595 | |
| 596 | Call::Config::BitrateConfigMask mask; |
| 597 | mask.max_bitrate_bps = rtc::Optional<int>(1000); |
| 598 | |
| 599 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, testing::_, 1000)); |
| 600 | call->SetBitrateConfigMask(mask); |
| 601 | } |
| 602 | |
| 603 | TEST(CallBitrateTest, SettingMaskStartForcesUpdate) { |
| 604 | CallBitrateHelper call; |
| 605 | |
| 606 | Call::Config::BitrateConfigMask mask; |
| 607 | mask.start_bitrate_bps = rtc::Optional<int>(1000); |
| 608 | |
| 609 | // SetBweBitrates should be called twice with the same params since |
| 610 | // start_bitrate_bps is set. |
| 611 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, 1000, testing::_)) |
| 612 | .Times(2); |
| 613 | call->SetBitrateConfigMask(mask); |
| 614 | call->SetBitrateConfigMask(mask); |
| 615 | } |
| 616 | |
| 617 | TEST(CallBitrateTest, SetBitrateConfigWithNoChangesDoesNotCallSetBweBitrates) { |
| 618 | CallBitrateHelper call; |
| 619 | |
| 620 | Call::Config::BitrateConfig config1; |
| 621 | config1.min_bitrate_bps = 0; |
| 622 | config1.start_bitrate_bps = 1000; |
| 623 | config1.max_bitrate_bps = -1; |
| 624 | |
| 625 | Call::Config::BitrateConfig config2; |
| 626 | config2.min_bitrate_bps = 0; |
| 627 | config2.start_bitrate_bps = -1; |
| 628 | config2.max_bitrate_bps = -1; |
| 629 | |
| 630 | // The second call should not call SetBweBitrates because it doesn't |
| 631 | // change any values. |
| 632 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1)); |
| 633 | call->SetBitrateConfig(config1); |
| 634 | call->SetBitrateConfig(config2); |
| 635 | } |
| 636 | |
| 637 | // If SetBitrateConfig changes the max, but not the effective max, |
| 638 | // SetBweBitrates shouldn't be called, to avoid unnecessary encoder |
| 639 | // reconfigurations. |
| 640 | TEST(CallBitrateTest, SetBweBitratesNotCalledWhenEffectiveMaxUnchanged) { |
| 641 | CallBitrateHelper call; |
| 642 | |
| 643 | Call::Config::BitrateConfig config; |
| 644 | config.min_bitrate_bps = 0; |
| 645 | config.start_bitrate_bps = -1; |
| 646 | config.max_bitrate_bps = 2000; |
| 647 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 2000)); |
| 648 | call->SetBitrateConfig(config); |
| 649 | |
| 650 | // Reduce effective max to 1000 with the mask. |
| 651 | Call::Config::BitrateConfigMask mask; |
| 652 | mask.max_bitrate_bps = rtc::Optional<int>(1000); |
| 653 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(testing::_, testing::_, 1000)); |
| 654 | call->SetBitrateConfigMask(mask); |
| 655 | |
| 656 | // This leaves the effective max unchanged, so SetBweBitrates shouldn't be |
| 657 | // called again. |
| 658 | config.max_bitrate_bps = 1000; |
| 659 | call->SetBitrateConfig(config); |
| 660 | } |
| 661 | |
| 662 | // When the "start bitrate" mask is removed, SetBweBitrates shouldn't be called |
| 663 | // again, since nothing's changing. |
| 664 | TEST(CallBitrateTest, SetBweBitratesNotCalledWhenStartMaskRemoved) { |
| 665 | CallBitrateHelper call; |
| 666 | |
| 667 | Call::Config::BitrateConfigMask mask; |
| 668 | mask.start_bitrate_bps = rtc::Optional<int>(1000); |
| 669 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1)); |
| 670 | call->SetBitrateConfigMask(mask); |
| 671 | |
| 672 | mask.start_bitrate_bps.reset(); |
| 673 | call->SetBitrateConfigMask(mask); |
| 674 | } |
| 675 | |
| 676 | // Test that if SetBitrateConfig is called after SetBitrateConfigMask applies a |
| 677 | // "start" value, the SetBitrateConfig call won't apply that start value a |
| 678 | // second time. |
| 679 | TEST(CallBitrateTest, SetBitrateConfigAfterSetBitrateConfigMaskWithStart) { |
| 680 | CallBitrateHelper call; |
| 681 | |
| 682 | Call::Config::BitrateConfigMask mask; |
| 683 | mask.start_bitrate_bps = rtc::Optional<int>(1000); |
| 684 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, 1000, -1)); |
| 685 | call->SetBitrateConfigMask(mask); |
| 686 | |
| 687 | Call::Config::BitrateConfig config; |
| 688 | config.min_bitrate_bps = 0; |
| 689 | config.start_bitrate_bps = -1; |
| 690 | config.max_bitrate_bps = 5000; |
| 691 | // The start value isn't changing, so SetBweBitrates should be called with |
| 692 | // -1. |
| 693 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(0, -1, 5000)); |
| 694 | call->SetBitrateConfig(config); |
| 695 | } |
| 696 | |
| 697 | TEST(CallBitrateTest, SetBweBitratesNotCalledWhenClampedMinUnchanged) { |
| 698 | Call::Config::BitrateConfig bitrate_config; |
| 699 | bitrate_config.start_bitrate_bps = 500; |
| 700 | bitrate_config.max_bitrate_bps = 1000; |
| 701 | CallBitrateHelper call(bitrate_config); |
| 702 | |
| 703 | // Set min to 2000; it is clamped to the max (1000). |
| 704 | Call::Config::BitrateConfigMask mask; |
| 705 | mask.min_bitrate_bps = rtc::Optional<int>(2000); |
| 706 | EXPECT_CALL(call.mock_cc(), SetBweBitrates(1000, -1, 1000)); |
| 707 | call->SetBitrateConfigMask(mask); |
| 708 | |
| 709 | // Set min to 3000; the clamped value stays the same so nothing happens. |
| 710 | mask.min_bitrate_bps = rtc::Optional<int>(3000); |
| 711 | call->SetBitrateConfigMask(mask); |
| 712 | } |
ossu | c3d4b48 | 2017-05-23 06:07:11 -0700 | [diff] [blame] | 713 | |
solenberg | c7a8b08 | 2015-10-16 14:35:07 -0700 | [diff] [blame] | 714 | } // namespace webrtc |