call_unittest.cc (17267B)
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 "call/call.h" 12 13 #include <cstdint> 14 #include <list> 15 #include <memory> 16 #include <string> 17 #include <utility> 18 #include <vector> 19 20 #include "absl/strings/string_view.h" 21 #include "api/adaptation/resource.h" 22 #include "api/environment/environment.h" 23 #include "api/environment/environment_factory.h" 24 #include "api/make_ref_counted.h" 25 #include "api/media_types.h" 26 #include "api/scoped_refptr.h" 27 #include "api/test/mock_audio_mixer.h" 28 #include "api/test/video/function_video_encoder_factory.h" 29 #include "api/units/timestamp.h" 30 #include "api/video/builtin_video_bitrate_allocator_factory.h" 31 #include "api/video_codecs/sdp_video_format.h" 32 #include "audio/audio_send_stream.h" 33 #include "call/adaptation/test/fake_resource.h" 34 #include "call/adaptation/test/mock_resource_listener.h" 35 #include "call/audio_receive_stream.h" 36 #include "call/audio_send_stream.h" 37 #include "call/audio_state.h" 38 #include "call/call_config.h" 39 #include "call/flexfec_receive_stream.h" 40 #include "call/video_send_stream.h" 41 #include "modules/audio_device/include/mock_audio_device.h" 42 #include "modules/audio_processing/include/mock_audio_processing.h" 43 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 44 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 45 #include "test/fake_encoder.h" 46 #include "test/gmock.h" 47 #include "test/gtest.h" 48 #include "test/mock_audio_decoder_factory.h" 49 #include "test/mock_transport.h" 50 #include "test/run_loop.h" 51 #include "video/config/video_encoder_config.h" 52 53 namespace webrtc { 54 namespace { 55 56 using test::FakeEncoder; 57 using test::FunctionVideoEncoderFactory; 58 using test::MockAudioDeviceModule; 59 using test::MockAudioMixer; 60 using test::MockAudioProcessing; 61 using test::RunLoop; 62 using ::testing::_; 63 using ::testing::MockFunction; 64 using ::testing::NiceMock; 65 using ::testing::StrictMock; 66 67 struct CallHelper { 68 explicit CallHelper(bool use_null_audio_processing) { 69 AudioState::Config audio_state_config; 70 audio_state_config.audio_mixer = make_ref_counted<MockAudioMixer>(); 71 audio_state_config.audio_processing = 72 use_null_audio_processing 73 ? nullptr 74 : make_ref_counted<NiceMock<MockAudioProcessing>>(); 75 audio_state_config.audio_device_module = 76 make_ref_counted<MockAudioDeviceModule>(); 77 CallConfig config(CreateEnvironment()); 78 config.audio_state = AudioState::Create(audio_state_config); 79 call_ = Call::Create(std::move(config)); 80 } 81 82 Call* operator->() { return call_.get(); } 83 84 private: 85 RunLoop loop_; 86 std::unique_ptr<Call> call_; 87 }; 88 89 scoped_refptr<Resource> FindResourceWhoseNameContains( 90 const std::vector<scoped_refptr<Resource>>& resources, 91 absl::string_view name_contains) { 92 for (const auto& resource : resources) { 93 if (resource->Name().find(std::string(name_contains)) != std::string::npos) 94 return resource; 95 } 96 return nullptr; 97 } 98 99 } // namespace 100 101 TEST(CallTest, ConstructDestruct) { 102 for (bool use_null_audio_processing : {false, true}) { 103 CallHelper call(use_null_audio_processing); 104 } 105 } 106 107 TEST(CallTest, CreateDestroy_AudioSendStream) { 108 for (bool use_null_audio_processing : {false, true}) { 109 CallHelper call(use_null_audio_processing); 110 MockTransport send_transport; 111 AudioSendStream::Config config(&send_transport); 112 config.rtp.ssrc = 42; 113 AudioSendStream* stream = call->CreateAudioSendStream(config); 114 EXPECT_NE(stream, nullptr); 115 call->DestroyAudioSendStream(stream); 116 } 117 } 118 119 TEST(CallTest, CreateDestroy_AudioReceiveStream) { 120 for (bool use_null_audio_processing : {false, true}) { 121 CallHelper call(use_null_audio_processing); 122 AudioReceiveStreamInterface::Config config; 123 MockTransport rtcp_send_transport; 124 config.rtp.remote_ssrc = 42; 125 config.rtcp_send_transport = &rtcp_send_transport; 126 config.decoder_factory = make_ref_counted<MockAudioDecoderFactory>(); 127 AudioReceiveStreamInterface* stream = 128 call->CreateAudioReceiveStream(config); 129 EXPECT_NE(stream, nullptr); 130 call->DestroyAudioReceiveStream(stream); 131 } 132 } 133 134 TEST(CallTest, CreateDestroy_AudioSendStreams) { 135 for (bool use_null_audio_processing : {false, true}) { 136 CallHelper call(use_null_audio_processing); 137 MockTransport send_transport; 138 AudioSendStream::Config config(&send_transport); 139 std::list<AudioSendStream*> streams; 140 for (int i = 0; i < 2; ++i) { 141 for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { 142 config.rtp.ssrc = ssrc; 143 AudioSendStream* stream = call->CreateAudioSendStream(config); 144 EXPECT_NE(stream, nullptr); 145 if (ssrc & 1) { 146 streams.push_back(stream); 147 } else { 148 streams.push_front(stream); 149 } 150 } 151 for (auto s : streams) { 152 call->DestroyAudioSendStream(s); 153 } 154 streams.clear(); 155 } 156 } 157 } 158 159 TEST(CallTest, CreateDestroy_AudioReceiveStreams) { 160 for (bool use_null_audio_processing : {false, true}) { 161 CallHelper call(use_null_audio_processing); 162 AudioReceiveStreamInterface::Config config; 163 MockTransport rtcp_send_transport; 164 config.rtcp_send_transport = &rtcp_send_transport; 165 config.decoder_factory = make_ref_counted<MockAudioDecoderFactory>(); 166 std::list<AudioReceiveStreamInterface*> streams; 167 for (int i = 0; i < 2; ++i) { 168 for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { 169 config.rtp.remote_ssrc = ssrc; 170 AudioReceiveStreamInterface* stream = 171 call->CreateAudioReceiveStream(config); 172 EXPECT_NE(stream, nullptr); 173 if (ssrc & 1) { 174 streams.push_back(stream); 175 } else { 176 streams.push_front(stream); 177 } 178 } 179 for (auto s : streams) { 180 call->DestroyAudioReceiveStream(s); 181 } 182 streams.clear(); 183 } 184 } 185 } 186 187 TEST(CallTest, CreateDestroy_FlexfecReceiveStream) { 188 for (bool use_null_audio_processing : {false, true}) { 189 CallHelper call(use_null_audio_processing); 190 MockTransport rtcp_send_transport; 191 FlexfecReceiveStream::Config config(&rtcp_send_transport); 192 config.payload_type = 118; 193 config.rtp.remote_ssrc = 38837212; 194 config.protected_media_ssrcs = {27273}; 195 196 FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); 197 EXPECT_NE(stream, nullptr); 198 call->DestroyFlexfecReceiveStream(stream); 199 } 200 } 201 202 TEST(CallTest, CreateDestroy_FlexfecReceiveStreams) { 203 for (bool use_null_audio_processing : {false, true}) { 204 CallHelper call(use_null_audio_processing); 205 MockTransport rtcp_send_transport; 206 FlexfecReceiveStream::Config config(&rtcp_send_transport); 207 config.payload_type = 118; 208 std::list<FlexfecReceiveStream*> streams; 209 210 for (int i = 0; i < 2; ++i) { 211 for (uint32_t ssrc = 0; ssrc < 1234567; ssrc += 34567) { 212 config.rtp.remote_ssrc = ssrc; 213 config.protected_media_ssrcs = {ssrc + 1}; 214 FlexfecReceiveStream* stream = call->CreateFlexfecReceiveStream(config); 215 EXPECT_NE(stream, nullptr); 216 if (ssrc & 1) { 217 streams.push_back(stream); 218 } else { 219 streams.push_front(stream); 220 } 221 } 222 for (auto s : streams) { 223 call->DestroyFlexfecReceiveStream(s); 224 } 225 streams.clear(); 226 } 227 } 228 } 229 230 TEST(CallTest, MultipleFlexfecReceiveStreamsProtectingSingleVideoStream) { 231 for (bool use_null_audio_processing : {false, true}) { 232 CallHelper call(use_null_audio_processing); 233 MockTransport rtcp_send_transport; 234 FlexfecReceiveStream::Config config(&rtcp_send_transport); 235 config.payload_type = 118; 236 config.protected_media_ssrcs = {1324234}; 237 FlexfecReceiveStream* stream; 238 std::list<FlexfecReceiveStream*> streams; 239 240 config.rtp.remote_ssrc = 838383; 241 stream = call->CreateFlexfecReceiveStream(config); 242 EXPECT_NE(stream, nullptr); 243 streams.push_back(stream); 244 245 config.rtp.remote_ssrc = 424993; 246 stream = call->CreateFlexfecReceiveStream(config); 247 EXPECT_NE(stream, nullptr); 248 streams.push_back(stream); 249 250 config.rtp.remote_ssrc = 99383; 251 stream = call->CreateFlexfecReceiveStream(config); 252 EXPECT_NE(stream, nullptr); 253 streams.push_back(stream); 254 255 config.rtp.remote_ssrc = 5548; 256 stream = call->CreateFlexfecReceiveStream(config); 257 EXPECT_NE(stream, nullptr); 258 streams.push_back(stream); 259 260 for (auto s : streams) { 261 call->DestroyFlexfecReceiveStream(s); 262 } 263 } 264 } 265 266 TEST(CallTest, 267 DeliverRtpPacketOfTypeAudioTriggerOnUndemuxablePacketHandlerIfNotDemuxed) { 268 CallHelper call(/*use_null_audio_processing=*/false); 269 MockFunction<bool(const RtpPacketReceived& parsed_packet)> 270 un_demuxable_packet_handler; 271 272 RtpPacketReceived packet; 273 packet.set_arrival_time(Timestamp::Millis(1)); 274 EXPECT_CALL(un_demuxable_packet_handler, Call); 275 call->Receiver()->DeliverRtpPacket( 276 MediaType::AUDIO, packet, un_demuxable_packet_handler.AsStdFunction()); 277 } 278 279 TEST(CallTest, 280 DeliverRtpPacketOfTypeVideoTriggerOnUndemuxablePacketHandlerIfNotDemuxed) { 281 CallHelper call(/*use_null_audio_processing=*/false); 282 MockFunction<bool(const RtpPacketReceived& parsed_packet)> 283 un_demuxable_packet_handler; 284 285 RtpPacketReceived packet; 286 packet.set_arrival_time(Timestamp::Millis(1)); 287 EXPECT_CALL(un_demuxable_packet_handler, Call); 288 call->Receiver()->DeliverRtpPacket( 289 MediaType::VIDEO, packet, un_demuxable_packet_handler.AsStdFunction()); 290 } 291 292 TEST(CallTest, 293 DeliverRtpPacketOfTypeAnyDoesNotTriggerOnUndemuxablePacketHandler) { 294 CallHelper call(/*use_null_audio_processing=*/false); 295 MockFunction<bool(const RtpPacketReceived& parsed_packet)> 296 un_demuxable_packet_handler; 297 298 RtpPacketReceived packet; 299 packet.set_arrival_time(Timestamp::Millis(1)); 300 EXPECT_CALL(un_demuxable_packet_handler, Call).Times(0); 301 call->Receiver()->DeliverRtpPacket( 302 MediaType::ANY, packet, un_demuxable_packet_handler.AsStdFunction()); 303 } 304 305 TEST(CallTest, RecreatingAudioStreamWithSameSsrcReusesRtpState) { 306 constexpr uint32_t kSSRC = 12345; 307 for (bool use_null_audio_processing : {false, true}) { 308 CallHelper call(use_null_audio_processing); 309 310 auto create_stream_and_get_rtp_state = [&](uint32_t ssrc) { 311 MockTransport send_transport; 312 AudioSendStream::Config config(&send_transport); 313 config.rtp.ssrc = ssrc; 314 AudioSendStream* stream = call->CreateAudioSendStream(config); 315 const RtpState rtp_state = 316 static_cast<internal::AudioSendStream*>(stream)->GetRtpState(); 317 call->DestroyAudioSendStream(stream); 318 return rtp_state; 319 }; 320 321 const RtpState rtp_state1 = create_stream_and_get_rtp_state(kSSRC); 322 const RtpState rtp_state2 = create_stream_and_get_rtp_state(kSSRC); 323 324 EXPECT_EQ(rtp_state1.sequence_number, rtp_state2.sequence_number); 325 EXPECT_EQ(rtp_state1.start_timestamp, rtp_state2.start_timestamp); 326 EXPECT_EQ(rtp_state1.timestamp, rtp_state2.timestamp); 327 EXPECT_EQ(rtp_state1.capture_time, rtp_state2.capture_time); 328 EXPECT_EQ(rtp_state1.last_timestamp_time, rtp_state2.last_timestamp_time); 329 } 330 } 331 332 TEST(CallTest, AddAdaptationResourceAfterCreatingVideoSendStream) { 333 CallHelper call(true); 334 // Create a VideoSendStream. 335 FunctionVideoEncoderFactory fake_encoder_factory( 336 [](const Environment& env, const SdpVideoFormat& /* format */) { 337 return std::make_unique<FakeEncoder>(env); 338 }); 339 auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory(); 340 MockTransport send_transport; 341 VideoSendStream::Config config(&send_transport); 342 config.rtp.payload_type = 110; 343 config.rtp.ssrcs = {42}; 344 config.encoder_settings.encoder_factory = &fake_encoder_factory; 345 config.encoder_settings.bitrate_allocator_factory = 346 bitrate_allocator_factory.get(); 347 VideoEncoderConfig encoder_config; 348 encoder_config.max_bitrate_bps = 1337; 349 VideoSendStream* stream1 = 350 call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); 351 EXPECT_NE(stream1, nullptr); 352 config.rtp.ssrcs = {43}; 353 VideoSendStream* stream2 = 354 call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); 355 EXPECT_NE(stream2, nullptr); 356 // Add a fake resource. 357 auto fake_resource = FakeResource::Create("FakeResource"); 358 call->AddAdaptationResource(fake_resource); 359 // An adapter resource mirroring the `fake_resource` should now be present on 360 // both streams. 361 auto injected_resource1 = FindResourceWhoseNameContains( 362 stream1->GetAdaptationResources(), fake_resource->Name()); 363 EXPECT_TRUE(injected_resource1); 364 auto injected_resource2 = FindResourceWhoseNameContains( 365 stream2->GetAdaptationResources(), fake_resource->Name()); 366 EXPECT_TRUE(injected_resource2); 367 // Overwrite the real resource listeners with mock ones to verify the signal 368 // gets through. 369 injected_resource1->SetResourceListener(nullptr); 370 StrictMock<MockResourceListener> resource_listener1; 371 EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _)) 372 .Times(1) 373 .WillOnce([injected_resource1](scoped_refptr<Resource> resource, 374 ResourceUsageState usage_state) { 375 EXPECT_EQ(injected_resource1, resource); 376 EXPECT_EQ(ResourceUsageState::kOveruse, usage_state); 377 }); 378 injected_resource1->SetResourceListener(&resource_listener1); 379 injected_resource2->SetResourceListener(nullptr); 380 StrictMock<MockResourceListener> resource_listener2; 381 EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _)) 382 .Times(1) 383 .WillOnce([injected_resource2](scoped_refptr<Resource> resource, 384 ResourceUsageState usage_state) { 385 EXPECT_EQ(injected_resource2, resource); 386 EXPECT_EQ(ResourceUsageState::kOveruse, usage_state); 387 }); 388 injected_resource2->SetResourceListener(&resource_listener2); 389 // The kOveruse signal should get to our resource listeners. 390 fake_resource->SetUsageState(ResourceUsageState::kOveruse); 391 call->DestroyVideoSendStream(stream1); 392 call->DestroyVideoSendStream(stream2); 393 } 394 395 TEST(CallTest, AddAdaptationResourceBeforeCreatingVideoSendStream) { 396 CallHelper call(true); 397 // Add a fake resource. 398 auto fake_resource = FakeResource::Create("FakeResource"); 399 call->AddAdaptationResource(fake_resource); 400 // Create a VideoSendStream. 401 FunctionVideoEncoderFactory fake_encoder_factory( 402 [](const Environment& env, const SdpVideoFormat& /* format */) { 403 return std::make_unique<FakeEncoder>(env); 404 }); 405 auto bitrate_allocator_factory = CreateBuiltinVideoBitrateAllocatorFactory(); 406 MockTransport send_transport; 407 VideoSendStream::Config config(&send_transport); 408 config.rtp.payload_type = 110; 409 config.rtp.ssrcs = {42}; 410 config.encoder_settings.encoder_factory = &fake_encoder_factory; 411 config.encoder_settings.bitrate_allocator_factory = 412 bitrate_allocator_factory.get(); 413 VideoEncoderConfig encoder_config; 414 encoder_config.max_bitrate_bps = 1337; 415 VideoSendStream* stream1 = 416 call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); 417 EXPECT_NE(stream1, nullptr); 418 config.rtp.ssrcs = {43}; 419 VideoSendStream* stream2 = 420 call->CreateVideoSendStream(config.Copy(), encoder_config.Copy()); 421 EXPECT_NE(stream2, nullptr); 422 // An adapter resource mirroring the `fake_resource` should be present on both 423 // streams. 424 auto injected_resource1 = FindResourceWhoseNameContains( 425 stream1->GetAdaptationResources(), fake_resource->Name()); 426 EXPECT_TRUE(injected_resource1); 427 auto injected_resource2 = FindResourceWhoseNameContains( 428 stream2->GetAdaptationResources(), fake_resource->Name()); 429 EXPECT_TRUE(injected_resource2); 430 // Overwrite the real resource listeners with mock ones to verify the signal 431 // gets through. 432 injected_resource1->SetResourceListener(nullptr); 433 StrictMock<MockResourceListener> resource_listener1; 434 EXPECT_CALL(resource_listener1, OnResourceUsageStateMeasured(_, _)) 435 .Times(1) 436 .WillOnce([injected_resource1](scoped_refptr<Resource> resource, 437 ResourceUsageState usage_state) { 438 EXPECT_EQ(injected_resource1, resource); 439 EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state); 440 }); 441 injected_resource1->SetResourceListener(&resource_listener1); 442 injected_resource2->SetResourceListener(nullptr); 443 StrictMock<MockResourceListener> resource_listener2; 444 EXPECT_CALL(resource_listener2, OnResourceUsageStateMeasured(_, _)) 445 .Times(1) 446 .WillOnce([injected_resource2](scoped_refptr<Resource> resource, 447 ResourceUsageState usage_state) { 448 EXPECT_EQ(injected_resource2, resource); 449 EXPECT_EQ(ResourceUsageState::kUnderuse, usage_state); 450 }); 451 injected_resource2->SetResourceListener(&resource_listener2); 452 // The kUnderuse signal should get to our resource listeners. 453 fake_resource->SetUsageState(ResourceUsageState::kUnderuse); 454 call->DestroyVideoSendStream(stream1); 455 call->DestroyVideoSendStream(stream2); 456 } 457 458 } // namespace webrtc