webrtc_voice_engine_unittest.cc (173836B)
1 /* 2 * Copyright (c) 2008 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 "media/engine/webrtc_voice_engine.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <cstring> 16 #include <map> 17 #include <memory> 18 #include <optional> 19 #include <set> 20 #include <string> 21 #include <utility> 22 #include <vector> 23 24 #include "absl/strings/match.h" 25 #include "absl/strings/string_view.h" 26 #include "api/array_view.h" 27 #include "api/audio/audio_processing.h" 28 #include "api/audio/builtin_audio_processing_builder.h" 29 #include "api/audio_codecs/audio_codec_pair_id.h" 30 #include "api/audio_codecs/audio_format.h" 31 #include "api/audio_codecs/builtin_audio_decoder_factory.h" 32 #include "api/audio_codecs/builtin_audio_encoder_factory.h" 33 #include "api/audio_options.h" 34 #include "api/call/audio_sink.h" 35 #include "api/call/transport.h" 36 #include "api/crypto/crypto_options.h" 37 #include "api/environment/environment.h" 38 #include "api/environment/environment_factory.h" 39 #include "api/field_trials.h" 40 #include "api/make_ref_counted.h" 41 #include "api/media_types.h" 42 #include "api/priority.h" 43 #include "api/ref_count.h" 44 #include "api/rtc_error.h" 45 #include "api/rtp_headers.h" 46 #include "api/rtp_parameters.h" 47 #include "api/scoped_refptr.h" 48 #include "api/transport/bitrate_settings.h" 49 #include "api/transport/rtp/rtp_source.h" 50 #include "call/audio_receive_stream.h" 51 #include "call/audio_send_stream.h" 52 #include "call/audio_state.h" 53 #include "call/call.h" 54 #include "call/call_config.h" 55 #include "call/payload_type_picker.h" 56 #include "media/base/audio_source.h" 57 #include "media/base/codec.h" 58 #include "media/base/fake_network_interface.h" 59 #include "media/base/fake_rtp.h" 60 #include "media/base/media_channel.h" 61 #include "media/base/media_config.h" 62 #include "media/base/media_constants.h" 63 #include "media/base/media_engine.h" 64 #include "media/base/stream_params.h" 65 #include "media/engine/fake_webrtc_call.h" 66 #include "modules/audio_device/include/mock_audio_device.h" 67 #include "modules/audio_mixer/audio_mixer_impl.h" 68 #include "modules/audio_processing/include/mock_audio_processing.h" 69 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" 70 #include "modules/rtp_rtcp/source/rtp_header_extensions.h" 71 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 72 #include "rtc_base/byte_order.h" 73 #include "rtc_base/checks.h" 74 #include "rtc_base/copy_on_write_buffer.h" 75 #include "rtc_base/dscp.h" 76 #include "rtc_base/numerics/safe_conversions.h" 77 #include "rtc_base/thread.h" 78 #include "test/create_test_field_trials.h" 79 #include "test/gmock.h" 80 #include "test/gtest.h" 81 #include "test/mock_audio_decoder_factory.h" 82 #include "test/mock_audio_encoder_factory.h" 83 84 namespace webrtc { 85 namespace { 86 using ::testing::_; 87 using ::testing::ContainerEq; 88 using ::testing::Contains; 89 using ::testing::Field; 90 using ::testing::IsEmpty; 91 using ::testing::Return; 92 using ::testing::ReturnPointee; 93 using ::testing::SaveArg; 94 using ::testing::StrictMock; 95 using ::testing::UnorderedElementsAreArray; 96 using ::webrtc::AudioProcessing; 97 using ::webrtc::BitrateConstraints; 98 using ::webrtc::BuiltinAudioProcessingBuilder; 99 using ::webrtc::Call; 100 using ::webrtc::CallConfig; 101 using ::webrtc::CreateEnvironment; 102 using ::webrtc::CreateTestFieldTrials; 103 using ::webrtc::Environment; 104 using ::webrtc::FieldTrials; 105 using ::webrtc::scoped_refptr; 106 107 constexpr uint32_t kMaxUnsignaledRecvStreams = 4; 108 109 const webrtc::Codec kPcmuCodec = webrtc::CreateAudioCodec(0, "PCMU", 8000, 1); 110 const webrtc::Codec kOpusCodec = 111 webrtc::CreateAudioCodec(111, "opus", 48000, 2); 112 const webrtc::Codec kG722CodecVoE = 113 webrtc::CreateAudioCodec(9, "G722", 16000, 1); 114 const webrtc::Codec kG722CodecSdp = 115 webrtc::CreateAudioCodec(9, "G722", 8000, 1); 116 const webrtc::Codec kCn8000Codec = webrtc::CreateAudioCodec(13, "CN", 8000, 1); 117 const webrtc::Codec kCn16000Codec = 118 webrtc::CreateAudioCodec(105, "CN", 16000, 1); 119 const webrtc::Codec kRed48000Codec = 120 webrtc::CreateAudioCodec(112, "RED", 48000, 2); 121 const webrtc::Codec kTelephoneEventCodec1 = 122 webrtc::CreateAudioCodec(106, "telephone-event", 8000, 1); 123 const webrtc::Codec kTelephoneEventCodec2 = 124 webrtc::CreateAudioCodec(107, "telephone-event", 32000, 1); 125 const webrtc::Codec kUnknownCodec = 126 webrtc::CreateAudioCodec(127, "XYZ", 32000, 1); 127 128 constexpr uint32_t kSsrc0 = 0; 129 constexpr uint32_t kSsrc1 = 1; 130 constexpr uint32_t kSsrcX = 0x99; 131 constexpr uint32_t kSsrcY = 0x17; 132 constexpr uint32_t kSsrcZ = 0x42; 133 constexpr uint32_t kSsrcW = 0x02; 134 constexpr uint32_t kSsrcs4[] = {11, 200, 30, 44}; 135 136 constexpr int kRtpHistoryMs = 5000; 137 138 constexpr webrtc::AudioProcessing::Config::GainController1::Mode 139 kDefaultAgcMode = 140 #if defined(WEBRTC_IOS) || defined(WEBRTC_ANDROID) 141 webrtc::AudioProcessing::Config::GainController1::kFixedDigital; 142 #else 143 webrtc::AudioProcessing::Config::GainController1::kAdaptiveAnalog; 144 #endif 145 146 constexpr webrtc::AudioProcessing::Config::NoiseSuppression::Level 147 kDefaultNsLevel = 148 webrtc::AudioProcessing::Config::NoiseSuppression::Level::kHigh; 149 150 void AdmSetupExpectations(webrtc::test::MockAudioDeviceModule* adm) { 151 RTC_DCHECK(adm); 152 153 // Setup. 154 EXPECT_CALL(*adm, Init()).WillOnce(Return(0)); 155 EXPECT_CALL(*adm, RegisterAudioCallback(_)).WillOnce(Return(0)); 156 #if defined(WEBRTC_WIN) 157 EXPECT_CALL( 158 *adm, 159 SetPlayoutDevice( 160 ::testing::Matcher<webrtc::AudioDeviceModule::WindowsDeviceType>( 161 webrtc::AudioDeviceModule::kDefaultCommunicationDevice))) 162 .WillOnce(Return(0)); 163 #else 164 EXPECT_CALL(*adm, SetPlayoutDevice(0)).WillOnce(Return(0)); 165 #endif // #if defined(WEBRTC_WIN) 166 EXPECT_CALL(*adm, InitSpeaker()).WillOnce(Return(0)); 167 EXPECT_CALL(*adm, StereoPlayoutIsAvailable(::testing::_)).WillOnce(Return(0)); 168 EXPECT_CALL(*adm, SetStereoPlayout(false)).WillOnce(Return(0)); 169 #if defined(WEBRTC_WIN) 170 EXPECT_CALL( 171 *adm, 172 SetRecordingDevice( 173 ::testing::Matcher<webrtc::AudioDeviceModule::WindowsDeviceType>( 174 webrtc::AudioDeviceModule::kDefaultCommunicationDevice))) 175 .WillOnce(Return(0)); 176 #else 177 EXPECT_CALL(*adm, SetRecordingDevice(0)).WillOnce(Return(0)); 178 #endif // #if defined(WEBRTC_WIN) 179 EXPECT_CALL(*adm, InitMicrophone()).WillOnce(Return(0)); 180 EXPECT_CALL(*adm, StereoRecordingIsAvailable(::testing::_)) 181 .WillOnce(Return(0)); 182 EXPECT_CALL(*adm, SetStereoRecording(false)).WillOnce(Return(0)); 183 EXPECT_CALL(*adm, BuiltInAECIsAvailable()).WillOnce(Return(false)); 184 EXPECT_CALL(*adm, BuiltInAGCIsAvailable()).WillOnce(Return(false)); 185 EXPECT_CALL(*adm, BuiltInNSIsAvailable()).WillOnce(Return(false)); 186 187 // Teardown. 188 EXPECT_CALL(*adm, StopPlayout()).WillOnce(Return(0)); 189 EXPECT_CALL(*adm, StopRecording()).WillOnce(Return(0)); 190 EXPECT_CALL(*adm, RegisterAudioCallback(nullptr)).WillOnce(Return(0)); 191 EXPECT_CALL(*adm, Terminate()).WillOnce(Return(0)); 192 } 193 194 std::vector<webrtc::Codec> AddIdToCodecs( 195 webrtc::PayloadTypePicker& pt_mapper, 196 std::vector<webrtc::Codec>&& codecs_in) { 197 std::vector<webrtc::Codec> codecs = std::move(codecs_in); 198 for (webrtc::Codec& codec : codecs) { 199 if (codec.id == webrtc::Codec::kIdNotSet) { 200 auto id_or_error = pt_mapper.SuggestMapping(codec, nullptr); 201 EXPECT_TRUE(id_or_error.ok()); 202 if (id_or_error.ok()) { 203 codec.id = id_or_error.value(); 204 } 205 } 206 } 207 return codecs; 208 } 209 210 std::vector<webrtc::Codec> ReceiveCodecsWithId( 211 webrtc::WebRtcVoiceEngine& engine) { 212 webrtc::PayloadTypePicker pt_mapper; 213 std::vector<webrtc::Codec> codecs = engine.LegacyRecvCodecs(); 214 return AddIdToCodecs(pt_mapper, std::move(codecs)); 215 } 216 217 // Tests that our stub library "works". 218 TEST(WebRtcVoiceEngineTestStubLibrary, StartupShutdown) { 219 Environment env = CreateEnvironment(); 220 for (bool use_null_apm : {false, true}) { 221 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 222 webrtc::test::MockAudioDeviceModule::CreateStrict(); 223 AdmSetupExpectations(adm.get()); 224 webrtc::scoped_refptr<StrictMock<webrtc::test::MockAudioProcessing>> apm = 225 use_null_apm ? nullptr 226 : webrtc::make_ref_counted< 227 StrictMock<webrtc::test::MockAudioProcessing>>(); 228 229 webrtc::AudioProcessing::Config apm_config; 230 if (!use_null_apm) { 231 EXPECT_CALL(*apm, GetConfig()).WillRepeatedly(ReturnPointee(&apm_config)); 232 EXPECT_CALL(*apm, ApplyConfig(_)).WillRepeatedly(SaveArg<0>(&apm_config)); 233 EXPECT_CALL(*apm, DetachAecDump()); 234 } 235 { 236 webrtc::WebRtcVoiceEngine engine( 237 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 238 webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm, 239 nullptr); 240 engine.Init(); 241 } 242 } 243 } 244 245 class FakeAudioSink : public webrtc::AudioSinkInterface { 246 public: 247 void OnData(const Data& /* audio */) override {} 248 }; 249 250 class FakeAudioSource : public webrtc::AudioSource { 251 void SetSink(Sink* /* sink */) override {} 252 }; 253 254 class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> { 255 public: 256 explicit WebRtcVoiceEngineTestFake(absl::string_view field_trials_string = "") 257 : use_null_apm_(GetParam()), 258 field_trials_(CreateTestFieldTrials(field_trials_string)), 259 env_(CreateEnvironment(&field_trials_)), 260 adm_(webrtc::test::MockAudioDeviceModule::CreateStrict()), 261 apm_(use_null_apm_ 262 ? nullptr 263 : webrtc::make_ref_counted< 264 StrictMock<webrtc::test::MockAudioProcessing>>()), 265 call_(env_) { 266 // AudioDeviceModule. 267 AdmSetupExpectations(adm_.get()); 268 269 if (!use_null_apm_) { 270 // AudioProcessing. 271 EXPECT_CALL(*apm_, GetConfig()) 272 .WillRepeatedly(ReturnPointee(&apm_config_)); 273 EXPECT_CALL(*apm_, ApplyConfig(_)) 274 .WillRepeatedly(SaveArg<0>(&apm_config_)); 275 EXPECT_CALL(*apm_, DetachAecDump()); 276 } 277 278 // Default Options. 279 // TODO(kwiberg): We should use mock factories here, but a bunch of 280 // the tests here probe the specific set of codecs provided by the builtin 281 // factories. Those tests should probably be moved elsewhere. 282 auto encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory(); 283 auto decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory(); 284 engine_ = std::make_unique<webrtc::WebRtcVoiceEngine>( 285 env_, adm_, encoder_factory, decoder_factory, nullptr, apm_, nullptr); 286 engine_->Init(); 287 send_parameters_.codecs.push_back(kPcmuCodec); 288 recv_parameters_.codecs.push_back(kPcmuCodec); 289 290 if (!use_null_apm_) { 291 // Default Options. 292 VerifyEchoCancellationSettings(/*enabled=*/true); 293 EXPECT_TRUE(IsHighPassFilterEnabled()); 294 EXPECT_TRUE(apm_config_.noise_suppression.enabled); 295 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 296 VerifyGainControlEnabledCorrectly(); 297 VerifyGainControlDefaultSettings(); 298 } 299 } 300 301 bool SetupChannel() { 302 send_channel_ = engine_->CreateSendChannel( 303 env_, &call_, webrtc::MediaConfig(), webrtc::AudioOptions(), 304 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 305 receive_channel_ = engine_->CreateReceiveChannel( 306 env_, &call_, webrtc::MediaConfig(), webrtc::AudioOptions(), 307 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 308 send_channel_->SetSsrcListChangedCallback( 309 [receive_channel = 310 receive_channel_.get()](const std::set<uint32_t>& choices) { 311 receive_channel->ChooseReceiverReportSsrc(choices); 312 }); 313 return true; 314 } 315 316 bool SetupRecvStream() { 317 if (!SetupChannel()) { 318 return false; 319 } 320 return AddRecvStream(kSsrcX); 321 } 322 323 bool SetupSendStream() { 324 return SetupSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX)); 325 } 326 327 bool SetupSendStream(const webrtc::StreamParams& sp) { 328 if (!SetupChannel()) { 329 return false; 330 } 331 if (!send_channel_->AddSendStream(sp)) { 332 return false; 333 } 334 if (!use_null_apm_) { 335 EXPECT_CALL(*apm_, set_output_will_be_muted(false)); 336 } 337 return send_channel_->SetAudioSend(kSsrcX, true, nullptr, &fake_source_); 338 } 339 340 bool AddRecvStream(uint32_t ssrc) { 341 EXPECT_TRUE(receive_channel_); 342 return receive_channel_->AddRecvStream( 343 webrtc::StreamParams::CreateLegacy(ssrc)); 344 } 345 346 void SetupForMultiSendStream() { 347 EXPECT_TRUE(SetupSendStream()); 348 // Remove stream added in Setup. 349 EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX)); 350 EXPECT_TRUE(send_channel_->RemoveSendStream(kSsrcX)); 351 // Verify the channel does not exist. 352 EXPECT_FALSE(call_.GetAudioSendStream(kSsrcX)); 353 } 354 355 void DeliverPacket(ArrayView<const uint8_t> data) { 356 webrtc::RtpPacketReceived packet; 357 packet.Parse(data); 358 receive_channel_->OnPacketReceived(packet); 359 webrtc::Thread::Current()->ProcessMessages(0); 360 } 361 362 const webrtc::FakeAudioSendStream& GetSendStream(uint32_t ssrc) { 363 const auto* send_stream = call_.GetAudioSendStream(ssrc); 364 EXPECT_TRUE(send_stream); 365 return *send_stream; 366 } 367 368 const webrtc::FakeAudioReceiveStream& GetRecvStream(uint32_t ssrc) { 369 const auto* recv_stream = call_.GetAudioReceiveStream(ssrc); 370 EXPECT_TRUE(recv_stream); 371 return *recv_stream; 372 } 373 374 const webrtc::AudioSendStream::Config& GetSendStreamConfig(uint32_t ssrc) { 375 return GetSendStream(ssrc).GetConfig(); 376 } 377 378 const webrtc::AudioReceiveStreamInterface::Config& GetRecvStreamConfig( 379 uint32_t ssrc) { 380 return GetRecvStream(ssrc).GetConfig(); 381 } 382 383 void SetSend(bool enable) { 384 ASSERT_TRUE(send_channel_); 385 if (enable) { 386 EXPECT_CALL(*adm_, RecordingIsInitialized()) 387 .Times(::testing::AtMost(1)) 388 .WillOnce(Return(false)); 389 EXPECT_CALL(*adm_, Recording()) 390 .Times(::testing::AtMost(1)) 391 .WillOnce(Return(false)); 392 EXPECT_CALL(*adm_, InitRecording()) 393 .Times(::testing::AtMost(1)) 394 .WillOnce(Return(0)); 395 } 396 send_channel_->SetSend(enable); 397 } 398 399 void SetSenderParameters(const webrtc::AudioSenderParameter& params) { 400 ASSERT_TRUE(send_channel_); 401 EXPECT_TRUE(send_channel_->SetSenderParameters(params)); 402 if (receive_channel_) { 403 receive_channel_->SetRtcpMode(params.rtcp.reduced_size 404 ? webrtc::RtcpMode::kReducedSize 405 : webrtc::RtcpMode::kCompound); 406 receive_channel_->SetReceiveNackEnabled( 407 send_channel_->SendCodecHasNack()); 408 receive_channel_->SetReceiveNonSenderRttEnabled( 409 send_channel_->SenderNonSenderRttEnabled()); 410 } 411 } 412 413 void SetAudioSend(uint32_t ssrc, 414 bool enable, 415 webrtc::AudioSource* source, 416 const webrtc::AudioOptions* options = nullptr) { 417 ASSERT_TRUE(send_channel_); 418 if (!use_null_apm_) { 419 EXPECT_CALL(*apm_, set_output_will_be_muted(!enable)); 420 } 421 EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source)); 422 } 423 424 void TestInsertDtmf(uint32_t ssrc, bool caller, const webrtc::Codec& codec) { 425 EXPECT_TRUE(SetupChannel()); 426 if (caller) { 427 // If this is a caller, local description will be applied and add the 428 // send stream. 429 EXPECT_TRUE(send_channel_->AddSendStream( 430 webrtc::StreamParams::CreateLegacy(kSsrcX))); 431 } 432 433 // Test we can only InsertDtmf when the other side supports telephone-event. 434 SetSenderParameters(send_parameters_); 435 SetSend(true); 436 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 437 EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 1, 111)); 438 send_parameters_.codecs.push_back(codec); 439 SetSenderParameters(send_parameters_); 440 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 441 442 if (!caller) { 443 // If this is callee, there's no active send channel yet. 444 EXPECT_FALSE(send_channel_->InsertDtmf(ssrc, 2, 123)); 445 EXPECT_TRUE(send_channel_->AddSendStream( 446 webrtc::StreamParams::CreateLegacy(kSsrcX))); 447 } 448 449 // Check we fail if the ssrc is invalid. 450 EXPECT_FALSE(send_channel_->InsertDtmf(-1, 1, 111)); 451 452 // Test send. 453 webrtc::FakeAudioSendStream::TelephoneEvent telephone_event = 454 GetSendStream(kSsrcX).GetLatestTelephoneEvent(); 455 EXPECT_EQ(-1, telephone_event.payload_type); 456 EXPECT_TRUE(send_channel_->InsertDtmf(ssrc, 2, 123)); 457 telephone_event = GetSendStream(kSsrcX).GetLatestTelephoneEvent(); 458 EXPECT_EQ(codec.id, telephone_event.payload_type); 459 EXPECT_EQ(codec.clockrate, telephone_event.payload_frequency); 460 EXPECT_EQ(2, telephone_event.event_code); 461 EXPECT_EQ(123, telephone_event.duration_ms); 462 } 463 464 void TestExtmapAllowMixedCaller(bool extmap_allow_mixed) { 465 // For a caller, the answer will be applied in set remote description 466 // where SetSenderParameters() is called. 467 EXPECT_TRUE(SetupChannel()); 468 EXPECT_TRUE(send_channel_->AddSendStream( 469 webrtc::StreamParams::CreateLegacy(kSsrcX))); 470 send_parameters_.extmap_allow_mixed = extmap_allow_mixed; 471 SetSenderParameters(send_parameters_); 472 const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX); 473 EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed); 474 } 475 476 void TestExtmapAllowMixedCallee(bool extmap_allow_mixed) { 477 // For a callee, the answer will be applied in set local description 478 // where SetExtmapAllowMixed() and AddSendStream() are called. 479 EXPECT_TRUE(SetupChannel()); 480 send_channel_->SetExtmapAllowMixed(extmap_allow_mixed); 481 EXPECT_TRUE(send_channel_->AddSendStream( 482 webrtc::StreamParams::CreateLegacy(kSsrcX))); 483 484 const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX); 485 EXPECT_EQ(extmap_allow_mixed, config.rtp.extmap_allow_mixed); 486 } 487 488 // Test that send bandwidth is set correctly. 489 // `codec` is the codec under test. 490 // `max_bitrate` is a parameter to set to SetMaxSendBandwidth(). 491 // `expected_result` is the expected result from SetMaxSendBandwidth(). 492 // `expected_bitrate` is the expected audio bitrate afterward. 493 void TestMaxSendBandwidth(const webrtc::Codec& codec, 494 int max_bitrate, 495 bool expected_result, 496 int expected_bitrate) { 497 webrtc::AudioSenderParameter parameters; 498 parameters.codecs.push_back(codec); 499 parameters.max_bandwidth_bps = max_bitrate; 500 if (expected_result) { 501 SetSenderParameters(parameters); 502 } else { 503 EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); 504 } 505 EXPECT_EQ(expected_bitrate, GetCodecBitrate(kSsrcX)); 506 } 507 508 // Sets the per-stream maximum bitrate limit for the specified SSRC. 509 bool SetMaxBitrateForStream(int32_t ssrc, int bitrate) { 510 webrtc::RtpParameters parameters = 511 send_channel_->GetRtpSendParameters(ssrc); 512 EXPECT_EQ(1UL, parameters.encodings.size()); 513 514 parameters.encodings[0].max_bitrate_bps = bitrate; 515 return send_channel_->SetRtpSendParameters(ssrc, parameters).ok(); 516 } 517 518 void SetGlobalMaxBitrate(const webrtc::Codec& codec, int bitrate) { 519 webrtc::AudioSenderParameter send_parameters; 520 send_parameters.codecs.push_back(codec); 521 send_parameters.max_bandwidth_bps = bitrate; 522 SetSenderParameters(send_parameters); 523 } 524 525 void CheckSendCodecBitrate(int32_t ssrc, 526 const char expected_name[], 527 int expected_bitrate) { 528 const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec; 529 EXPECT_EQ(expected_name, spec->format.name); 530 EXPECT_EQ(expected_bitrate, spec->target_bitrate_bps); 531 } 532 533 std::optional<int> GetCodecBitrate(int32_t ssrc) { 534 auto spec = GetSendStreamConfig(ssrc).send_codec_spec; 535 if (!spec.has_value()) { 536 return std::nullopt; 537 } 538 return spec->target_bitrate_bps; 539 } 540 541 int GetMaxBitrate(int32_t ssrc) { 542 return GetSendStreamConfig(ssrc).max_bitrate_bps; 543 } 544 545 const std::optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { 546 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; 547 } 548 549 void SetAndExpectMaxBitrate(const webrtc::Codec& codec, 550 int global_max, 551 int stream_max, 552 bool expected_result, 553 int expected_codec_bitrate) { 554 // Clear the bitrate limit from the previous test case. 555 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcX, -1)); 556 557 // Attempt to set the requested bitrate limits. 558 SetGlobalMaxBitrate(codec, global_max); 559 EXPECT_EQ(expected_result, SetMaxBitrateForStream(kSsrcX, stream_max)); 560 561 // Verify that reading back the parameters gives results 562 // consistent with the Set() result. 563 webrtc::RtpParameters resulting_parameters = 564 send_channel_->GetRtpSendParameters(kSsrcX); 565 EXPECT_EQ(1UL, resulting_parameters.encodings.size()); 566 EXPECT_EQ(expected_result ? stream_max : -1, 567 resulting_parameters.encodings[0].max_bitrate_bps); 568 569 // Verify that the codec settings have the expected bitrate. 570 EXPECT_EQ(expected_codec_bitrate, GetCodecBitrate(kSsrcX)); 571 EXPECT_EQ(expected_codec_bitrate, GetMaxBitrate(kSsrcX)); 572 } 573 574 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps, 575 int expected_min_bitrate_bps, 576 const char* start_bitrate_kbps, 577 int expected_start_bitrate_bps, 578 const char* max_bitrate_kbps, 579 int expected_max_bitrate_bps) { 580 EXPECT_TRUE(SetupSendStream()); 581 auto& codecs = send_parameters_.codecs; 582 codecs.clear(); 583 codecs.push_back(kOpusCodec); 584 codecs[0].params[webrtc::kCodecParamMinBitrate] = min_bitrate_kbps; 585 codecs[0].params[webrtc::kCodecParamStartBitrate] = start_bitrate_kbps; 586 codecs[0].params[webrtc::kCodecParamMaxBitrate] = max_bitrate_kbps; 587 EXPECT_CALL(*call_.GetMockTransportControllerSend(), 588 SetSdpBitrateParameters( 589 AllOf(Field(&BitrateConstraints::min_bitrate_bps, 590 expected_min_bitrate_bps), 591 Field(&BitrateConstraints::start_bitrate_bps, 592 expected_start_bitrate_bps), 593 Field(&BitrateConstraints::max_bitrate_bps, 594 expected_max_bitrate_bps)))); 595 596 SetSenderParameters(send_parameters_); 597 } 598 599 void TestSetSendRtpHeaderExtensions(const std::string& ext) { 600 EXPECT_TRUE(SetupSendStream()); 601 602 // Ensure extensions are off by default. 603 EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); 604 605 // Ensure unknown extensions won't cause an error. 606 send_parameters_.extensions.push_back( 607 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); 608 SetSenderParameters(send_parameters_); 609 EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); 610 611 // Ensure extensions stay off with an empty list of headers. 612 send_parameters_.extensions.clear(); 613 SetSenderParameters(send_parameters_); 614 EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); 615 616 // Ensure extension is set properly. 617 const int id = 1; 618 send_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); 619 SetSenderParameters(send_parameters_); 620 EXPECT_EQ(1u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); 621 EXPECT_EQ(ext, GetSendStreamConfig(kSsrcX).rtp.extensions[0].uri); 622 EXPECT_EQ(id, GetSendStreamConfig(kSsrcX).rtp.extensions[0].id); 623 624 // Ensure extension is set properly on new stream. 625 EXPECT_TRUE(send_channel_->AddSendStream( 626 webrtc::StreamParams::CreateLegacy(kSsrcY))); 627 EXPECT_NE(call_.GetAudioSendStream(kSsrcX), 628 call_.GetAudioSendStream(kSsrcY)); 629 EXPECT_EQ(1u, GetSendStreamConfig(kSsrcY).rtp.extensions.size()); 630 EXPECT_EQ(ext, GetSendStreamConfig(kSsrcY).rtp.extensions[0].uri); 631 EXPECT_EQ(id, GetSendStreamConfig(kSsrcY).rtp.extensions[0].id); 632 633 // Ensure all extensions go back off with an empty list. 634 send_parameters_.codecs.push_back(kPcmuCodec); 635 send_parameters_.extensions.clear(); 636 SetSenderParameters(send_parameters_); 637 EXPECT_EQ(0u, GetSendStreamConfig(kSsrcX).rtp.extensions.size()); 638 EXPECT_EQ(0u, GetSendStreamConfig(kSsrcY).rtp.extensions.size()); 639 } 640 641 void TestSetRecvRtpHeaderExtensions(const std::string& ext) { 642 EXPECT_TRUE(SetupRecvStream()); 643 644 // Ensure extensions are off by default. 645 EXPECT_THAT( 646 receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, 647 IsEmpty()); 648 649 // Ensure unknown extensions won't cause an error. 650 recv_parameters_.extensions.push_back( 651 webrtc::RtpExtension("urn:ietf:params:unknownextention", 1)); 652 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 653 EXPECT_THAT( 654 receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, 655 IsEmpty()); 656 657 // Ensure extensions stay off with an empty list of headers. 658 recv_parameters_.extensions.clear(); 659 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 660 EXPECT_THAT( 661 receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, 662 IsEmpty()); 663 664 // Ensure extension is set properly. 665 const int id = 2; 666 recv_parameters_.extensions.push_back(webrtc::RtpExtension(ext, id)); 667 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 668 EXPECT_EQ( 669 receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, 670 recv_parameters_.extensions); 671 672 // Ensure extension is set properly on new stream. 673 EXPECT_TRUE(AddRecvStream(kSsrcY)); 674 EXPECT_EQ( 675 receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions, 676 recv_parameters_.extensions); 677 678 // Ensure all extensions go back off with an empty list. 679 recv_parameters_.extensions.clear(); 680 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 681 EXPECT_THAT( 682 receive_channel_->GetRtpReceiverParameters(kSsrcX).header_extensions, 683 IsEmpty()); 684 EXPECT_THAT( 685 receive_channel_->GetRtpReceiverParameters(kSsrcY).header_extensions, 686 IsEmpty()); 687 } 688 689 webrtc::AudioSendStream::Stats GetAudioSendStreamStats() const { 690 webrtc::AudioSendStream::Stats stats; 691 stats.local_ssrc = 12; 692 stats.payload_bytes_sent = 345; 693 stats.header_and_padding_bytes_sent = 56; 694 stats.packets_sent = 678; 695 stats.packets_lost = 9012; 696 stats.fraction_lost = 34.56f; 697 stats.codec_name = "codec_name_send"; 698 stats.codec_payload_type = 0; 699 stats.jitter_ms = 12; 700 stats.rtt_ms = 345; 701 stats.audio_level = 678; 702 stats.apm_statistics.delay_median_ms = 234; 703 stats.apm_statistics.delay_standard_deviation_ms = 567; 704 stats.apm_statistics.echo_return_loss = 890; 705 stats.apm_statistics.echo_return_loss_enhancement = 1234; 706 stats.apm_statistics.residual_echo_likelihood = 0.432f; 707 stats.apm_statistics.residual_echo_likelihood_recent_max = 0.6f; 708 stats.ana_statistics.bitrate_action_counter = 321; 709 stats.ana_statistics.channel_action_counter = 432; 710 stats.ana_statistics.dtx_action_counter = 543; 711 stats.ana_statistics.fec_action_counter = 654; 712 stats.ana_statistics.frame_length_increase_counter = 765; 713 stats.ana_statistics.frame_length_decrease_counter = 876; 714 stats.ana_statistics.uplink_packet_loss_fraction = 987.0; 715 return stats; 716 } 717 void SetAudioSendStreamStats() { 718 for (auto* s : call_.GetAudioSendStreams()) { 719 s->SetStats(GetAudioSendStreamStats()); 720 } 721 } 722 void VerifyVoiceSenderInfo(const webrtc::VoiceSenderInfo& info, 723 bool /* is_sending */) { 724 const auto stats = GetAudioSendStreamStats(); 725 EXPECT_EQ(info.ssrc(), stats.local_ssrc); 726 EXPECT_EQ(info.payload_bytes_sent, stats.payload_bytes_sent); 727 EXPECT_EQ(info.header_and_padding_bytes_sent, 728 stats.header_and_padding_bytes_sent); 729 EXPECT_EQ(info.packets_sent, stats.packets_sent); 730 EXPECT_EQ(info.packets_lost, stats.packets_lost); 731 EXPECT_EQ(info.fraction_lost, stats.fraction_lost); 732 EXPECT_EQ(info.codec_name, stats.codec_name); 733 EXPECT_EQ(info.codec_payload_type, stats.codec_payload_type); 734 EXPECT_EQ(info.jitter_ms, stats.jitter_ms); 735 EXPECT_EQ(info.rtt_ms, stats.rtt_ms); 736 EXPECT_EQ(info.audio_level, stats.audio_level); 737 EXPECT_EQ(info.apm_statistics.delay_median_ms, 738 stats.apm_statistics.delay_median_ms); 739 EXPECT_EQ(info.apm_statistics.delay_standard_deviation_ms, 740 stats.apm_statistics.delay_standard_deviation_ms); 741 EXPECT_EQ(info.apm_statistics.echo_return_loss, 742 stats.apm_statistics.echo_return_loss); 743 EXPECT_EQ(info.apm_statistics.echo_return_loss_enhancement, 744 stats.apm_statistics.echo_return_loss_enhancement); 745 EXPECT_EQ(info.apm_statistics.residual_echo_likelihood, 746 stats.apm_statistics.residual_echo_likelihood); 747 EXPECT_EQ(info.apm_statistics.residual_echo_likelihood_recent_max, 748 stats.apm_statistics.residual_echo_likelihood_recent_max); 749 EXPECT_EQ(info.ana_statistics.bitrate_action_counter, 750 stats.ana_statistics.bitrate_action_counter); 751 EXPECT_EQ(info.ana_statistics.channel_action_counter, 752 stats.ana_statistics.channel_action_counter); 753 EXPECT_EQ(info.ana_statistics.dtx_action_counter, 754 stats.ana_statistics.dtx_action_counter); 755 EXPECT_EQ(info.ana_statistics.fec_action_counter, 756 stats.ana_statistics.fec_action_counter); 757 EXPECT_EQ(info.ana_statistics.frame_length_increase_counter, 758 stats.ana_statistics.frame_length_increase_counter); 759 EXPECT_EQ(info.ana_statistics.frame_length_decrease_counter, 760 stats.ana_statistics.frame_length_decrease_counter); 761 EXPECT_EQ(info.ana_statistics.uplink_packet_loss_fraction, 762 stats.ana_statistics.uplink_packet_loss_fraction); 763 } 764 765 webrtc::AudioReceiveStreamInterface::Stats GetAudioReceiveStreamStats() 766 const { 767 webrtc::AudioReceiveStreamInterface::Stats stats; 768 stats.remote_ssrc = 123; 769 stats.payload_bytes_received = 456; 770 stats.header_and_padding_bytes_received = 67; 771 stats.packets_received = 768; 772 stats.packets_lost = 101; 773 stats.codec_name = "codec_name_recv"; 774 stats.codec_payload_type = 0; 775 stats.jitter_ms = 901; 776 stats.jitter_buffer_ms = 234; 777 stats.jitter_buffer_preferred_ms = 567; 778 stats.delay_estimate_ms = 890; 779 stats.audio_level = 1234; 780 stats.total_samples_received = 5678901; 781 stats.concealed_samples = 234; 782 stats.concealment_events = 12; 783 stats.jitter_buffer_delay_seconds = 34; 784 stats.jitter_buffer_emitted_count = 77; 785 stats.total_processing_delay_seconds = 0.123; 786 stats.expand_rate = 5.67f; 787 stats.speech_expand_rate = 8.90f; 788 stats.secondary_decoded_rate = 1.23f; 789 stats.secondary_discarded_rate = 0.12f; 790 stats.accelerate_rate = 4.56f; 791 stats.preemptive_expand_rate = 7.89f; 792 stats.decoding_calls_to_silence_generator = 12; 793 stats.decoding_calls_to_neteq = 345; 794 stats.decoding_normal = 67890; 795 stats.decoding_plc = 1234; 796 stats.decoding_codec_plc = 1236; 797 stats.decoding_cng = 5678; 798 stats.decoding_plc_cng = 9012; 799 stats.decoding_muted_output = 3456; 800 stats.capture_start_ntp_time_ms = 7890; 801 return stats; 802 } 803 void SetAudioReceiveStreamStats() { 804 for (auto* s : call_.GetAudioReceiveStreams()) { 805 s->SetStats(GetAudioReceiveStreamStats()); 806 } 807 } 808 void VerifyVoiceReceiverInfo(const webrtc::VoiceReceiverInfo& info) { 809 const auto stats = GetAudioReceiveStreamStats(); 810 EXPECT_EQ(info.ssrc(), stats.remote_ssrc); 811 EXPECT_EQ(info.payload_bytes_received, stats.payload_bytes_received); 812 EXPECT_EQ(info.header_and_padding_bytes_received, 813 stats.header_and_padding_bytes_received); 814 EXPECT_EQ(webrtc::checked_cast<unsigned int>(info.packets_received), 815 stats.packets_received); 816 EXPECT_EQ(info.packets_lost, stats.packets_lost); 817 EXPECT_EQ(info.codec_name, stats.codec_name); 818 EXPECT_EQ(info.codec_payload_type, stats.codec_payload_type); 819 EXPECT_EQ(webrtc::checked_cast<unsigned int>(info.jitter_ms), 820 stats.jitter_ms); 821 EXPECT_EQ(webrtc::checked_cast<unsigned int>(info.jitter_buffer_ms), 822 stats.jitter_buffer_ms); 823 EXPECT_EQ( 824 webrtc::checked_cast<unsigned int>(info.jitter_buffer_preferred_ms), 825 stats.jitter_buffer_preferred_ms); 826 EXPECT_EQ(webrtc::checked_cast<unsigned int>(info.delay_estimate_ms), 827 stats.delay_estimate_ms); 828 EXPECT_EQ(info.audio_level, stats.audio_level); 829 EXPECT_EQ(info.total_samples_received, stats.total_samples_received); 830 EXPECT_EQ(info.concealed_samples, stats.concealed_samples); 831 EXPECT_EQ(info.concealment_events, stats.concealment_events); 832 EXPECT_EQ(info.jitter_buffer_delay_seconds, 833 stats.jitter_buffer_delay_seconds); 834 EXPECT_EQ(info.jitter_buffer_emitted_count, 835 stats.jitter_buffer_emitted_count); 836 EXPECT_EQ(info.total_processing_delay_seconds, 837 stats.total_processing_delay_seconds); 838 EXPECT_EQ(info.expand_rate, stats.expand_rate); 839 EXPECT_EQ(info.speech_expand_rate, stats.speech_expand_rate); 840 EXPECT_EQ(info.secondary_decoded_rate, stats.secondary_decoded_rate); 841 EXPECT_EQ(info.secondary_discarded_rate, stats.secondary_discarded_rate); 842 EXPECT_EQ(info.accelerate_rate, stats.accelerate_rate); 843 EXPECT_EQ(info.preemptive_expand_rate, stats.preemptive_expand_rate); 844 EXPECT_EQ(info.decoding_calls_to_silence_generator, 845 stats.decoding_calls_to_silence_generator); 846 EXPECT_EQ(info.decoding_calls_to_neteq, stats.decoding_calls_to_neteq); 847 EXPECT_EQ(info.decoding_normal, stats.decoding_normal); 848 EXPECT_EQ(info.decoding_plc, stats.decoding_plc); 849 EXPECT_EQ(info.decoding_codec_plc, stats.decoding_codec_plc); 850 EXPECT_EQ(info.decoding_cng, stats.decoding_cng); 851 EXPECT_EQ(info.decoding_plc_cng, stats.decoding_plc_cng); 852 EXPECT_EQ(info.decoding_muted_output, stats.decoding_muted_output); 853 EXPECT_EQ(info.capture_start_ntp_time_ms, stats.capture_start_ntp_time_ms); 854 } 855 void VerifyVoiceSendRecvCodecs( 856 const webrtc::VoiceMediaSendInfo& send_info, 857 const webrtc::VoiceMediaReceiveInfo& receive_info) const { 858 EXPECT_EQ(send_parameters_.codecs.size(), send_info.send_codecs.size()); 859 for (const webrtc::Codec& codec : send_parameters_.codecs) { 860 ASSERT_EQ(send_info.send_codecs.count(codec.id), 1U); 861 EXPECT_EQ(send_info.send_codecs.find(codec.id)->second, 862 codec.ToCodecParameters()); 863 } 864 EXPECT_EQ(recv_parameters_.codecs.size(), 865 receive_info.receive_codecs.size()); 866 for (const webrtc::Codec& codec : recv_parameters_.codecs) { 867 ASSERT_EQ(receive_info.receive_codecs.count(codec.id), 1U); 868 EXPECT_EQ(receive_info.receive_codecs.find(codec.id)->second, 869 codec.ToCodecParameters()); 870 } 871 } 872 873 void VerifyGainControlEnabledCorrectly() { 874 EXPECT_TRUE(apm_config_.gain_controller1.enabled); 875 EXPECT_EQ(kDefaultAgcMode, apm_config_.gain_controller1.mode); 876 } 877 878 void VerifyGainControlDefaultSettings() { 879 EXPECT_EQ(3, apm_config_.gain_controller1.target_level_dbfs); 880 EXPECT_EQ(9, apm_config_.gain_controller1.compression_gain_db); 881 EXPECT_TRUE(apm_config_.gain_controller1.enable_limiter); 882 } 883 884 void VerifyEchoCancellationSettings(bool enabled) { 885 EXPECT_EQ(apm_config_.echo_canceller.enabled, enabled); 886 EXPECT_EQ(apm_config_.echo_canceller.mobile_mode, false); 887 } 888 889 bool IsHighPassFilterEnabled() { 890 return apm_config_.high_pass_filter.enabled; 891 } 892 893 webrtc::WebRtcVoiceSendChannel* SendImplFromPointer( 894 webrtc::VoiceMediaSendChannelInterface* channel) { 895 return static_cast<webrtc::WebRtcVoiceSendChannel*>(channel); 896 } 897 898 webrtc::WebRtcVoiceSendChannel* SendImpl() { 899 return SendImplFromPointer(send_channel_.get()); 900 } 901 webrtc::WebRtcVoiceReceiveChannel* ReceiveImpl() { 902 return static_cast<webrtc::WebRtcVoiceReceiveChannel*>( 903 receive_channel_.get()); 904 } 905 std::vector<webrtc::Codec> SendCodecsWithId() { 906 std::vector<webrtc::Codec> codecs = engine_->LegacySendCodecs(); 907 return AddIdToCodecs(pt_mapper_, std::move(codecs)); 908 } 909 910 protected: 911 webrtc::AutoThread main_thread_; 912 const bool use_null_apm_; 913 FieldTrials field_trials_; 914 const Environment env_; 915 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm_; 916 webrtc::scoped_refptr<StrictMock<webrtc::test::MockAudioProcessing>> apm_; 917 webrtc::FakeCall call_; 918 FakeAudioSource fake_source_; 919 std::unique_ptr<webrtc::WebRtcVoiceEngine> engine_; 920 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel_; 921 std::unique_ptr<webrtc::VoiceMediaReceiveChannelInterface> receive_channel_; 922 webrtc::AudioSenderParameter send_parameters_; 923 webrtc::AudioReceiverParameters recv_parameters_; 924 webrtc::AudioProcessing::Config apm_config_; 925 webrtc::PayloadTypePicker pt_mapper_; 926 }; 927 928 INSTANTIATE_TEST_SUITE_P(TestBothWithAndWithoutNullApm, 929 WebRtcVoiceEngineTestFake, 930 ::testing::Values(false, true)); 931 932 // Tests that we can create and destroy a channel. 933 TEST_P(WebRtcVoiceEngineTestFake, CreateMediaChannel) { 934 EXPECT_TRUE(SetupChannel()); 935 } 936 937 // Test that we can add a send stream and that it has the correct defaults. 938 TEST_P(WebRtcVoiceEngineTestFake, CreateSendStream) { 939 EXPECT_TRUE(SetupChannel()); 940 EXPECT_TRUE( 941 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 942 const webrtc::AudioSendStream::Config& config = GetSendStreamConfig(kSsrcX); 943 EXPECT_EQ(kSsrcX, config.rtp.ssrc); 944 EXPECT_EQ("", config.rtp.c_name); 945 EXPECT_EQ(0u, config.rtp.extensions.size()); 946 EXPECT_EQ(SendImpl()->transport(), config.send_transport); 947 } 948 949 // Test that we can add a receive stream and that it has the correct defaults. 950 TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) { 951 EXPECT_TRUE(SetupChannel()); 952 EXPECT_TRUE(AddRecvStream(kSsrcX)); 953 const webrtc::AudioReceiveStreamInterface::Config& config = 954 GetRecvStreamConfig(kSsrcX); 955 EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc); 956 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); 957 EXPECT_EQ(ReceiveImpl()->transport(), config.rtcp_send_transport); 958 EXPECT_EQ("", config.sync_group); 959 } 960 961 // Test that we set our inbound codecs properly, including changing PT. 962 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecs) { 963 EXPECT_TRUE(SetupChannel()); 964 webrtc::AudioReceiverParameters parameters; 965 parameters.codecs.push_back(kOpusCodec); 966 parameters.codecs.push_back(kPcmuCodec); 967 parameters.codecs.push_back(kTelephoneEventCodec1); 968 parameters.codecs.push_back(kTelephoneEventCodec2); 969 parameters.codecs[0].id = 106; // collide with existing CN 32k 970 parameters.codecs[2].id = 126; 971 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 972 EXPECT_TRUE(AddRecvStream(kSsrcX)); 973 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 974 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 975 {{0, {"PCMU", 8000, 1}}, 976 {106, {"OPUS", 48000, 2}}, 977 {126, {"telephone-event", 8000, 1}}, 978 {107, {"telephone-event", 32000, 1}}}))); 979 } 980 981 // Test that we fail to set an unknown inbound codec. 982 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsUnsupportedCodec) { 983 EXPECT_TRUE(SetupChannel()); 984 webrtc::AudioReceiverParameters parameters; 985 parameters.codecs.push_back(kOpusCodec); 986 parameters.codecs.push_back(kUnknownCodec); 987 EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); 988 } 989 990 // Test that we fail if we have duplicate types in the inbound list. 991 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsDuplicatePayloadType) { 992 EXPECT_TRUE(SetupChannel()); 993 webrtc::AudioReceiverParameters parameters; 994 parameters.codecs.push_back(kOpusCodec); 995 parameters.codecs.push_back(kCn16000Codec); 996 parameters.codecs[1].id = kOpusCodec.id; 997 EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); 998 } 999 1000 // Test that we can decode OPUS without stereo parameters. 1001 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { 1002 EXPECT_TRUE(SetupChannel()); 1003 webrtc::AudioReceiverParameters parameters; 1004 parameters.codecs.push_back(kPcmuCodec); 1005 parameters.codecs.push_back(kOpusCodec); 1006 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1007 EXPECT_TRUE(AddRecvStream(kSsrcX)); 1008 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 1009 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 1010 {{0, {"PCMU", 8000, 1}}, {111, {"opus", 48000, 2}}}))); 1011 } 1012 1013 // Test that we can decode OPUS with stereo = 0. 1014 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { 1015 EXPECT_TRUE(SetupChannel()); 1016 webrtc::AudioReceiverParameters parameters; 1017 parameters.codecs.push_back(kPcmuCodec); 1018 parameters.codecs.push_back(kOpusCodec); 1019 parameters.codecs[1].params["stereo"] = "0"; 1020 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1021 EXPECT_TRUE(AddRecvStream(kSsrcX)); 1022 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 1023 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 1024 {{0, {"PCMU", 8000, 1}}, 1025 {111, {"opus", 48000, 2, {{"stereo", "0"}}}}}))); 1026 } 1027 1028 // Test that we can decode OPUS with stereo = 1. 1029 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { 1030 EXPECT_TRUE(SetupChannel()); 1031 webrtc::AudioReceiverParameters parameters; 1032 parameters.codecs.push_back(kPcmuCodec); 1033 parameters.codecs.push_back(kOpusCodec); 1034 parameters.codecs[1].params["stereo"] = "1"; 1035 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1036 EXPECT_TRUE(AddRecvStream(kSsrcX)); 1037 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 1038 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 1039 {{0, {"PCMU", 8000, 1}}, 1040 {111, {"opus", 48000, 2, {{"stereo", "1"}}}}}))); 1041 } 1042 1043 // Test that changes to recv codecs are applied to all streams. 1044 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { 1045 EXPECT_TRUE(SetupChannel()); 1046 webrtc::AudioReceiverParameters parameters; 1047 parameters.codecs.push_back(kOpusCodec); 1048 parameters.codecs.push_back(kPcmuCodec); 1049 parameters.codecs.push_back(kTelephoneEventCodec1); 1050 parameters.codecs.push_back(kTelephoneEventCodec2); 1051 parameters.codecs[0].id = 106; // collide with existing CN 32k 1052 parameters.codecs[2].id = 126; 1053 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1054 for (const auto& ssrc : {kSsrcX, kSsrcY}) { 1055 EXPECT_TRUE(AddRecvStream(ssrc)); 1056 EXPECT_THAT(GetRecvStreamConfig(ssrc).decoder_map, 1057 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 1058 {{0, {"PCMU", 8000, 1}}, 1059 {106, {"OPUS", 48000, 2}}, 1060 {126, {"telephone-event", 8000, 1}}, 1061 {107, {"telephone-event", 32000, 1}}}))); 1062 } 1063 } 1064 1065 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsAfterAddingStreams) { 1066 EXPECT_TRUE(SetupRecvStream()); 1067 webrtc::AudioReceiverParameters parameters; 1068 parameters.codecs.push_back(kOpusCodec); 1069 parameters.codecs[0].id = 106; // collide with existing CN 32k 1070 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1071 1072 const auto& dm = GetRecvStreamConfig(kSsrcX).decoder_map; 1073 ASSERT_EQ(1u, dm.count(106)); 1074 EXPECT_EQ(webrtc::SdpAudioFormat("opus", 48000, 2), dm.at(106)); 1075 } 1076 1077 // Test that we can apply the same set of codecs again while playing. 1078 TEST_P(WebRtcVoiceEngineTestFake, SetRecvCodecsWhilePlaying) { 1079 EXPECT_TRUE(SetupRecvStream()); 1080 webrtc::AudioReceiverParameters parameters; 1081 parameters.codecs.push_back(kPcmuCodec); 1082 parameters.codecs.push_back(kCn16000Codec); 1083 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1084 receive_channel_->SetPlayout(true); 1085 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1086 1087 // Remapping a payload type to a different codec should fail. 1088 parameters.codecs[0] = kOpusCodec; 1089 parameters.codecs[0].id = kPcmuCodec.id; 1090 EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters)); 1091 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); 1092 } 1093 1094 // Test that we can add a codec while playing. 1095 TEST_P(WebRtcVoiceEngineTestFake, AddRecvCodecsWhilePlaying) { 1096 EXPECT_TRUE(SetupRecvStream()); 1097 webrtc::AudioReceiverParameters parameters; 1098 parameters.codecs.push_back(kPcmuCodec); 1099 parameters.codecs.push_back(kCn16000Codec); 1100 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1101 receive_channel_->SetPlayout(true); 1102 1103 parameters.codecs.push_back(kOpusCodec); 1104 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1105 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); 1106 } 1107 1108 // Test that we accept adding the same codec with a different payload type. 1109 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5847 1110 TEST_P(WebRtcVoiceEngineTestFake, ChangeRecvCodecPayloadType) { 1111 EXPECT_TRUE(SetupRecvStream()); 1112 webrtc::AudioReceiverParameters parameters; 1113 parameters.codecs.push_back(kOpusCodec); 1114 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1115 1116 ++parameters.codecs[0].id; 1117 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1118 } 1119 1120 // Test that we do allow setting Opus/Red by default. 1121 TEST_P(WebRtcVoiceEngineTestFake, RecvRedDefault) { 1122 EXPECT_TRUE(SetupRecvStream()); 1123 webrtc::AudioReceiverParameters parameters; 1124 parameters.codecs.push_back(kOpusCodec); 1125 parameters.codecs.push_back(kRed48000Codec); 1126 parameters.codecs[1].params[""] = "111/111"; 1127 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1128 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 1129 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 1130 {{111, {"opus", 48000, 2}}, 1131 {112, {"red", 48000, 2, {{"", "111/111"}}}}}))); 1132 } 1133 1134 TEST_P(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { 1135 EXPECT_TRUE(SetupSendStream()); 1136 1137 // Test that when autobw is enabled, bitrate is kept as the default 1138 // value. autobw is enabled for the following tests because the target 1139 // bitrate is <= 0. 1140 1141 // PCMU, default bitrate == 64000. 1142 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); 1143 1144 // opus, default bitrate == 32000 in mono. 1145 TestMaxSendBandwidth(kOpusCodec, -1, true, 32000); 1146 } 1147 1148 TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { 1149 EXPECT_TRUE(SetupSendStream()); 1150 1151 // opus, default bitrate == 64000. 1152 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); 1153 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); 1154 // Rates above the max (510000) should be capped. 1155 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); 1156 } 1157 1158 TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { 1159 EXPECT_TRUE(SetupSendStream()); 1160 1161 // Test that we can only set a maximum bitrate for a fixed-rate codec 1162 // if it's bigger than the fixed rate. 1163 1164 // PCMU, fixed bitrate == 64000. 1165 TestMaxSendBandwidth(kPcmuCodec, 0, true, 64000); 1166 TestMaxSendBandwidth(kPcmuCodec, 1, false, 64000); 1167 TestMaxSendBandwidth(kPcmuCodec, 128000, true, 64000); 1168 TestMaxSendBandwidth(kPcmuCodec, 32000, false, 64000); 1169 TestMaxSendBandwidth(kPcmuCodec, 64000, true, 64000); 1170 TestMaxSendBandwidth(kPcmuCodec, 63999, false, 64000); 1171 TestMaxSendBandwidth(kPcmuCodec, 64001, true, 64000); 1172 } 1173 1174 TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { 1175 EXPECT_TRUE(SetupChannel()); 1176 const int kDesiredBitrate = 128000; 1177 webrtc::AudioSenderParameter parameters; 1178 parameters.codecs = SendCodecsWithId(); 1179 parameters.max_bandwidth_bps = kDesiredBitrate; 1180 SetSenderParameters(parameters); 1181 1182 EXPECT_TRUE( 1183 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 1184 1185 EXPECT_EQ(kDesiredBitrate, GetCodecBitrate(kSsrcX)); 1186 } 1187 1188 // Test that bitrate cannot be set for CBR codecs. 1189 // Bitrate is ignored if it is higher than the fixed bitrate. 1190 // Bitrate less then the fixed bitrate is an error. 1191 TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthCbr) { 1192 EXPECT_TRUE(SetupSendStream()); 1193 1194 // PCMU, default bitrate == 64000. 1195 SetSenderParameters(send_parameters_); 1196 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); 1197 1198 send_parameters_.max_bandwidth_bps = 128000; 1199 SetSenderParameters(send_parameters_); 1200 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); 1201 1202 send_parameters_.max_bandwidth_bps = 128; 1203 EXPECT_FALSE(send_channel_->SetSenderParameters(send_parameters_)); 1204 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); 1205 } 1206 1207 // Test that the per-stream bitrate limit and the global 1208 // bitrate limit both apply. 1209 TEST_P(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { 1210 EXPECT_TRUE(SetupSendStream()); 1211 1212 // opus, default bitrate == 32000. 1213 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000); 1214 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); 1215 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); 1216 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); 1217 1218 // CBR codecs allow both maximums to exceed the bitrate. 1219 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); 1220 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); 1221 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); 1222 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); 1223 1224 // CBR codecs don't allow per stream maximums to be too low. 1225 SetAndExpectMaxBitrate(kPcmuCodec, 0, 63999, false, 64000); 1226 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 63999, false, 64000); 1227 } 1228 1229 // Test that an attempt to set RtpParameters for a stream that does not exist 1230 // fails. 1231 TEST_P(WebRtcVoiceEngineTestFake, CannotSetMaxBitrateForNonexistentStream) { 1232 EXPECT_TRUE(SetupChannel()); 1233 webrtc::RtpParameters nonexistent_parameters = 1234 send_channel_->GetRtpSendParameters(kSsrcX); 1235 EXPECT_EQ(0u, nonexistent_parameters.encodings.size()); 1236 1237 nonexistent_parameters.encodings.push_back(webrtc::RtpEncodingParameters()); 1238 EXPECT_FALSE( 1239 send_channel_->SetRtpSendParameters(kSsrcX, nonexistent_parameters).ok()); 1240 } 1241 1242 TEST_P(WebRtcVoiceEngineTestFake, 1243 CannotSetRtpSendParametersWithIncorrectNumberOfEncodings) { 1244 // This test verifies that setting RtpParameters succeeds only if 1245 // the structure contains exactly one encoding. 1246 // TODO(skvlad): Update this test when we start supporting setting parameters 1247 // for each encoding individually. 1248 1249 EXPECT_TRUE(SetupSendStream()); 1250 webrtc::RtpParameters parameters = 1251 send_channel_->GetRtpSendParameters(kSsrcX); 1252 // Two or more encodings should result in failure. 1253 parameters.encodings.push_back(webrtc::RtpEncodingParameters()); 1254 EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1255 // Zero encodings should also fail. 1256 parameters.encodings.clear(); 1257 EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1258 } 1259 1260 // Changing the SSRC through RtpParameters is not allowed. 1261 TEST_P(WebRtcVoiceEngineTestFake, CannotSetSsrcInRtpSendParameters) { 1262 EXPECT_TRUE(SetupSendStream()); 1263 webrtc::RtpParameters parameters = 1264 send_channel_->GetRtpSendParameters(kSsrcX); 1265 parameters.encodings[0].ssrc = 0xdeadbeef; 1266 EXPECT_FALSE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1267 } 1268 1269 // Test that a stream will not be sending if its encoding is made 1270 // inactive through SetRtpSendParameters. 1271 TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersEncodingsActive) { 1272 EXPECT_TRUE(SetupSendStream()); 1273 SetSend(true); 1274 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 1275 // Get current parameters and change "active" to false. 1276 webrtc::RtpParameters parameters = 1277 send_channel_->GetRtpSendParameters(kSsrcX); 1278 ASSERT_EQ(1u, parameters.encodings.size()); 1279 ASSERT_TRUE(parameters.encodings[0].active); 1280 parameters.encodings[0].active = false; 1281 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1282 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 1283 1284 // Now change it back to active and verify we resume sending. 1285 // This should occur even when other parameters are updated. 1286 parameters.encodings[0].active = true; 1287 parameters.encodings[0].max_bitrate_bps = std::optional<int>(6000); 1288 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1289 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 1290 } 1291 1292 TEST_P(WebRtcVoiceEngineTestFake, SetRtpParametersAdaptivePtime) { 1293 EXPECT_TRUE(SetupSendStream()); 1294 // Get current parameters and change "adaptive_ptime" to true. 1295 webrtc::RtpParameters parameters = 1296 send_channel_->GetRtpSendParameters(kSsrcX); 1297 ASSERT_EQ(1u, parameters.encodings.size()); 1298 ASSERT_FALSE(parameters.encodings[0].adaptive_ptime); 1299 parameters.encodings[0].adaptive_ptime = true; 1300 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1301 EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX)); 1302 EXPECT_EQ(16000, GetSendStreamConfig(kSsrcX).min_bitrate_bps); 1303 1304 parameters.encodings[0].adaptive_ptime = false; 1305 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1306 EXPECT_FALSE(GetAudioNetworkAdaptorConfig(kSsrcX)); 1307 EXPECT_EQ(32000, GetSendStreamConfig(kSsrcX).min_bitrate_bps); 1308 } 1309 1310 TEST_P(WebRtcVoiceEngineTestFake, 1311 DisablingAdaptivePtimeDoesNotRemoveAudioNetworkAdaptorFromOptions) { 1312 EXPECT_TRUE(SetupSendStream()); 1313 send_parameters_.options.audio_network_adaptor = true; 1314 send_parameters_.options.audio_network_adaptor_config = {"1234"}; 1315 SetSenderParameters(send_parameters_); 1316 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 1317 GetAudioNetworkAdaptorConfig(kSsrcX)); 1318 1319 webrtc::RtpParameters parameters = 1320 send_channel_->GetRtpSendParameters(kSsrcX); 1321 parameters.encodings[0].adaptive_ptime = false; 1322 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, parameters).ok()); 1323 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 1324 GetAudioNetworkAdaptorConfig(kSsrcX)); 1325 } 1326 1327 class WebRtcVoiceEngineTestWithAdaptivePtime 1328 : public WebRtcVoiceEngineTestFake { 1329 public: 1330 WebRtcVoiceEngineTestWithAdaptivePtime() 1331 : WebRtcVoiceEngineTestFake("WebRTC-Audio-AdaptivePtime/enabled:true/") {} 1332 }; 1333 1334 TEST_P(WebRtcVoiceEngineTestWithAdaptivePtime, AdaptivePtimeFieldTrial) { 1335 // field_trials_.Set("WebRTC-Audio-AdaptivePtime", "enabled:true"); 1336 EXPECT_TRUE(SetupSendStream()); 1337 EXPECT_TRUE(GetAudioNetworkAdaptorConfig(kSsrcX)); 1338 } 1339 1340 INSTANTIATE_TEST_SUITE_P(TestBothWithAndWithoutNullApm, 1341 WebRtcVoiceEngineTestWithAdaptivePtime, 1342 ::testing::Values(false, true)); 1343 1344 // Test that SetRtpSendParameters configures the correct encoding channel for 1345 // each SSRC. 1346 TEST_P(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { 1347 SetupForMultiSendStream(); 1348 // Create send streams. 1349 for (uint32_t ssrc : kSsrcs4) { 1350 EXPECT_TRUE( 1351 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(ssrc))); 1352 } 1353 // Configure one stream to be limited by the stream config, another to be 1354 // limited by the global max, and the third one with no per-stream limit 1355 // (still subject to the global limit). 1356 SetGlobalMaxBitrate(kOpusCodec, 32000); 1357 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000)); 1358 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000)); 1359 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); 1360 1361 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); 1362 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1])); 1363 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); 1364 1365 // Remove the global cap; the streams should switch to their respective 1366 // maximums (or remain unchanged if there was no other limit on them.) 1367 SetGlobalMaxBitrate(kOpusCodec, -1); 1368 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); 1369 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1])); 1370 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); 1371 } 1372 1373 // Test that GetRtpSendParameters returns the currently configured codecs. 1374 TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { 1375 EXPECT_TRUE(SetupSendStream()); 1376 webrtc::AudioSenderParameter parameters; 1377 parameters.codecs.push_back(kOpusCodec); 1378 parameters.codecs.push_back(kPcmuCodec); 1379 SetSenderParameters(parameters); 1380 1381 webrtc::RtpParameters rtp_parameters = 1382 send_channel_->GetRtpSendParameters(kSsrcX); 1383 ASSERT_EQ(2u, rtp_parameters.codecs.size()); 1384 EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]); 1385 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); 1386 } 1387 1388 // Test that GetRtpSendParameters returns the currently configured RTCP CNAME. 1389 TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersRtcpCname) { 1390 webrtc::StreamParams params = webrtc::StreamParams::CreateLegacy(kSsrcX); 1391 params.cname = "rtcpcname"; 1392 EXPECT_TRUE(SetupSendStream(params)); 1393 1394 webrtc::RtpParameters rtp_parameters = 1395 send_channel_->GetRtpSendParameters(kSsrcX); 1396 EXPECT_STREQ("rtcpcname", rtp_parameters.rtcp.cname.c_str()); 1397 } 1398 1399 TEST_P(WebRtcVoiceEngineTestFake, 1400 DetectRtpSendParameterHeaderExtensionsChange) { 1401 EXPECT_TRUE(SetupSendStream()); 1402 1403 webrtc::RtpParameters rtp_parameters = 1404 send_channel_->GetRtpSendParameters(kSsrcX); 1405 rtp_parameters.header_extensions.emplace_back(); 1406 1407 EXPECT_NE(0u, rtp_parameters.header_extensions.size()); 1408 1409 webrtc::RTCError result = 1410 send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters); 1411 EXPECT_EQ(webrtc::RTCErrorType::INVALID_MODIFICATION, result.type()); 1412 } 1413 1414 // Test that GetRtpSendParameters returns an SSRC. 1415 TEST_P(WebRtcVoiceEngineTestFake, GetRtpSendParametersSsrc) { 1416 EXPECT_TRUE(SetupSendStream()); 1417 webrtc::RtpParameters rtp_parameters = 1418 send_channel_->GetRtpSendParameters(kSsrcX); 1419 ASSERT_EQ(1u, rtp_parameters.encodings.size()); 1420 EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc); 1421 } 1422 1423 // Test that if we set/get parameters multiple times, we get the same results. 1424 TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpSendParameters) { 1425 EXPECT_TRUE(SetupSendStream()); 1426 webrtc::AudioSenderParameter parameters; 1427 parameters.codecs.push_back(kOpusCodec); 1428 parameters.codecs.push_back(kPcmuCodec); 1429 SetSenderParameters(parameters); 1430 1431 webrtc::RtpParameters initial_params = 1432 send_channel_->GetRtpSendParameters(kSsrcX); 1433 1434 // We should be able to set the params we just got. 1435 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, initial_params).ok()); 1436 1437 // ... And this shouldn't change the params returned by GetRtpSendParameters. 1438 webrtc::RtpParameters new_params = 1439 send_channel_->GetRtpSendParameters(kSsrcX); 1440 EXPECT_EQ(initial_params, send_channel_->GetRtpSendParameters(kSsrcX)); 1441 } 1442 1443 // Test that we remove the codec from RTP parameters if it's not negotiated 1444 // anymore. 1445 TEST_P(WebRtcVoiceEngineTestFake, 1446 SetSendParametersRemovesSelectedCodecFromRtpParameters) { 1447 EXPECT_TRUE(SetupSendStream()); 1448 webrtc::AudioSenderParameter parameters; 1449 parameters.codecs.push_back(kOpusCodec); 1450 parameters.codecs.push_back(kPcmuCodec); 1451 SetSenderParameters(parameters); 1452 1453 webrtc::RtpParameters initial_params = 1454 send_channel_->GetRtpSendParameters(kSsrcX); 1455 1456 webrtc::RtpCodec opus_rtp_codec; 1457 opus_rtp_codec.name = "opus"; 1458 opus_rtp_codec.kind = webrtc::MediaType::AUDIO; 1459 opus_rtp_codec.num_channels = 2; 1460 opus_rtp_codec.clock_rate = 48000; 1461 initial_params.encodings[0].codec = opus_rtp_codec; 1462 1463 // We should be able to set the params with the opus codec that has been 1464 // negotiated. 1465 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, initial_params).ok()); 1466 1467 parameters.codecs.clear(); 1468 parameters.codecs.push_back(kPcmuCodec); 1469 SetSenderParameters(parameters); 1470 1471 // Since Opus is no longer negotiated, the RTP parameters should not have a 1472 // forced codec anymore. 1473 webrtc::RtpParameters new_params = 1474 send_channel_->GetRtpSendParameters(kSsrcX); 1475 EXPECT_EQ(new_params.encodings[0].codec, std::nullopt); 1476 } 1477 1478 // Test that max_bitrate_bps in send stream config gets updated correctly when 1479 // SetRtpSendParameters is called. 1480 TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) { 1481 EXPECT_TRUE(SetupSendStream()); 1482 webrtc::AudioSenderParameter send_parameters; 1483 send_parameters.codecs.push_back(kOpusCodec); 1484 SetSenderParameters(send_parameters); 1485 1486 webrtc::RtpParameters rtp_parameters = 1487 send_channel_->GetRtpSendParameters(kSsrcX); 1488 // Expect empty on parameters.encodings[0].max_bitrate_bps; 1489 EXPECT_FALSE(rtp_parameters.encodings[0].max_bitrate_bps); 1490 1491 constexpr int kMaxBitrateBps = 6000; 1492 rtp_parameters.encodings[0].max_bitrate_bps = kMaxBitrateBps; 1493 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok()); 1494 1495 const int max_bitrate = GetSendStreamConfig(kSsrcX).max_bitrate_bps; 1496 EXPECT_EQ(max_bitrate, kMaxBitrateBps); 1497 } 1498 1499 // Tests that when RTCRtpEncodingParameters.bitrate_priority gets set to 1500 // a value <= 0, setting the parameters returns false. 1501 TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterInvalidBitratePriority) { 1502 EXPECT_TRUE(SetupSendStream()); 1503 webrtc::RtpParameters rtp_parameters = 1504 send_channel_->GetRtpSendParameters(kSsrcX); 1505 EXPECT_EQ(1UL, rtp_parameters.encodings.size()); 1506 EXPECT_EQ(webrtc::kDefaultBitratePriority, 1507 rtp_parameters.encodings[0].bitrate_priority); 1508 1509 rtp_parameters.encodings[0].bitrate_priority = 0; 1510 EXPECT_FALSE( 1511 send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok()); 1512 rtp_parameters.encodings[0].bitrate_priority = -1.0; 1513 EXPECT_FALSE( 1514 send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok()); 1515 } 1516 1517 // Test that the bitrate_priority in the send stream config gets updated when 1518 // SetRtpSendParameters is set for the VoiceMediaChannel. 1519 TEST_P(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesBitratePriority) { 1520 EXPECT_TRUE(SetupSendStream()); 1521 webrtc::RtpParameters rtp_parameters = 1522 send_channel_->GetRtpSendParameters(kSsrcX); 1523 1524 EXPECT_EQ(1UL, rtp_parameters.encodings.size()); 1525 EXPECT_EQ(webrtc::kDefaultBitratePriority, 1526 rtp_parameters.encodings[0].bitrate_priority); 1527 double new_bitrate_priority = 2.0; 1528 rtp_parameters.encodings[0].bitrate_priority = new_bitrate_priority; 1529 EXPECT_TRUE(send_channel_->SetRtpSendParameters(kSsrcX, rtp_parameters).ok()); 1530 1531 // The priority should get set for both the audio channel's rtp parameters 1532 // and the audio send stream's audio config. 1533 EXPECT_EQ(new_bitrate_priority, send_channel_->GetRtpSendParameters(kSsrcX) 1534 .encodings[0] 1535 .bitrate_priority); 1536 EXPECT_EQ(new_bitrate_priority, GetSendStreamConfig(kSsrcX).bitrate_priority); 1537 } 1538 1539 // Test that GetRtpReceiverParameters returns the currently configured codecs. 1540 TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersCodecs) { 1541 EXPECT_TRUE(SetupRecvStream()); 1542 webrtc::AudioReceiverParameters parameters; 1543 parameters.codecs.push_back(kOpusCodec); 1544 parameters.codecs.push_back(kPcmuCodec); 1545 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1546 1547 webrtc::RtpParameters rtp_parameters = 1548 receive_channel_->GetRtpReceiverParameters(kSsrcX); 1549 ASSERT_EQ(2u, rtp_parameters.codecs.size()); 1550 EXPECT_EQ(kOpusCodec.ToCodecParameters(), rtp_parameters.codecs[0]); 1551 EXPECT_EQ(kPcmuCodec.ToCodecParameters(), rtp_parameters.codecs[1]); 1552 } 1553 1554 // Test that GetRtpReceiverParameters returns an SSRC. 1555 TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersSsrc) { 1556 EXPECT_TRUE(SetupRecvStream()); 1557 webrtc::RtpParameters rtp_parameters = 1558 receive_channel_->GetRtpReceiverParameters(kSsrcX); 1559 ASSERT_EQ(1u, rtp_parameters.encodings.size()); 1560 EXPECT_EQ(kSsrcX, rtp_parameters.encodings[0].ssrc); 1561 } 1562 1563 // Test that if we set/get parameters multiple times, we get the same results. 1564 TEST_P(WebRtcVoiceEngineTestFake, SetAndGetRtpReceiveParameters) { 1565 EXPECT_TRUE(SetupRecvStream()); 1566 webrtc::AudioReceiverParameters parameters; 1567 parameters.codecs.push_back(kOpusCodec); 1568 parameters.codecs.push_back(kPcmuCodec); 1569 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1570 1571 webrtc::RtpParameters initial_params = 1572 receive_channel_->GetRtpReceiverParameters(kSsrcX); 1573 1574 // ... And this shouldn't change the params returned by 1575 // GetRtpReceiverParameters. 1576 webrtc::RtpParameters new_params = 1577 receive_channel_->GetRtpReceiverParameters(kSsrcX); 1578 EXPECT_EQ(initial_params, receive_channel_->GetRtpReceiverParameters(kSsrcX)); 1579 } 1580 1581 // Test that GetRtpReceiverParameters returns parameters correctly when SSRCs 1582 // aren't signaled. It should return an empty "RtpEncodingParameters" when 1583 // configured to receive an unsignaled stream and no packets have been received 1584 // yet, and start returning the SSRC once a packet has been received. 1585 TEST_P(WebRtcVoiceEngineTestFake, GetRtpReceiveParametersWithUnsignaledSsrc) { 1586 ASSERT_TRUE(SetupChannel()); 1587 // Call necessary methods to configure receiving a default stream as 1588 // soon as it arrives. 1589 webrtc::AudioReceiverParameters parameters; 1590 parameters.codecs.push_back(kOpusCodec); 1591 parameters.codecs.push_back(kPcmuCodec); 1592 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1593 1594 // Call GetDefaultRtpReceiveParameters before configured to receive an 1595 // unsignaled stream. Should return nothing. 1596 EXPECT_EQ(webrtc::RtpParameters(), 1597 receive_channel_->GetDefaultRtpReceiveParameters()); 1598 1599 // Set a sink for an unsignaled stream. 1600 std::unique_ptr<FakeAudioSink> fake_sink(new FakeAudioSink()); 1601 receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink)); 1602 1603 // Call GetDefaultRtpReceiveParameters before the SSRC is known. 1604 webrtc::RtpParameters rtp_parameters = 1605 receive_channel_->GetDefaultRtpReceiveParameters(); 1606 ASSERT_EQ(1u, rtp_parameters.encodings.size()); 1607 EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); 1608 1609 // Receive PCMU packet (SSRC=1). 1610 DeliverPacket(kPcmuFrame); 1611 1612 // The `ssrc` member should still be unset. 1613 rtp_parameters = receive_channel_->GetDefaultRtpReceiveParameters(); 1614 ASSERT_EQ(1u, rtp_parameters.encodings.size()); 1615 EXPECT_FALSE(rtp_parameters.encodings[0].ssrc); 1616 } 1617 1618 TEST_P(WebRtcVoiceEngineTestFake, OnPacketReceivedIdentifiesExtensions) { 1619 ASSERT_TRUE(SetupChannel()); 1620 webrtc::AudioReceiverParameters parameters = recv_parameters_; 1621 parameters.extensions.push_back( 1622 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, /*id=*/1)); 1623 ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 1624 webrtc::RtpHeaderExtensionMap extension_map(parameters.extensions); 1625 webrtc::RtpPacketReceived reference_packet(&extension_map); 1626 constexpr uint8_t kAudioLevel = 123; 1627 reference_packet.SetExtension<webrtc::AudioLevelExtension>( 1628 webrtc::AudioLevel(/*voice_activity=*/true, kAudioLevel)); 1629 // Create a packet without the extension map but with the same content. 1630 webrtc::RtpPacketReceived received_packet; 1631 ASSERT_TRUE(received_packet.Parse(reference_packet.Buffer())); 1632 1633 receive_channel_->OnPacketReceived(received_packet); 1634 webrtc::Thread::Current()->ProcessMessages(0); 1635 1636 webrtc::AudioLevel audio_level; 1637 EXPECT_TRUE(call_.last_received_rtp_packet() 1638 .GetExtension<webrtc::AudioLevelExtension>(&audio_level)); 1639 EXPECT_EQ(audio_level.level(), kAudioLevel); 1640 } 1641 1642 // Test that we apply codecs properly. 1643 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecs) { 1644 EXPECT_TRUE(SetupSendStream()); 1645 webrtc::AudioSenderParameter parameters; 1646 parameters.codecs.push_back(kOpusCodec); 1647 parameters.codecs.push_back(kPcmuCodec); 1648 parameters.codecs.push_back(kCn8000Codec); 1649 parameters.codecs[0].id = 96; 1650 parameters.codecs[0].bitrate = 22000; 1651 SetSenderParameters(parameters); 1652 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1653 EXPECT_EQ(96, send_codec_spec.payload_type); 1654 EXPECT_EQ(22000, send_codec_spec.target_bitrate_bps); 1655 EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str()); 1656 EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000); 1657 EXPECT_EQ(std::nullopt, send_codec_spec.cng_payload_type); 1658 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 1659 } 1660 1661 // Test that we use Opus/Red by default when it is 1662 // listed as the first codec and there is an fmtp line. 1663 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRed) { 1664 EXPECT_TRUE(SetupSendStream()); 1665 webrtc::AudioSenderParameter parameters; 1666 parameters.codecs.push_back(kRed48000Codec); 1667 parameters.codecs[0].params[""] = "111/111"; 1668 parameters.codecs.push_back(kOpusCodec); 1669 SetSenderParameters(parameters); 1670 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1671 EXPECT_EQ(111, send_codec_spec.payload_type); 1672 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1673 EXPECT_EQ(112, send_codec_spec.red_payload_type); 1674 } 1675 1676 // Test that we do not use Opus/Red by default when it is 1677 // listed as the first codec but there is no fmtp line. 1678 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedNoFmtp) { 1679 EXPECT_TRUE(SetupSendStream()); 1680 webrtc::AudioSenderParameter parameters; 1681 parameters.codecs.push_back(kRed48000Codec); 1682 parameters.codecs.push_back(kOpusCodec); 1683 SetSenderParameters(parameters); 1684 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1685 EXPECT_EQ(111, send_codec_spec.payload_type); 1686 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1687 EXPECT_EQ(std::nullopt, send_codec_spec.red_payload_type); 1688 } 1689 1690 // Test that we do not use Opus/Red by default. 1691 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedDefault) { 1692 EXPECT_TRUE(SetupSendStream()); 1693 webrtc::AudioSenderParameter parameters; 1694 parameters.codecs.push_back(kOpusCodec); 1695 parameters.codecs.push_back(kRed48000Codec); 1696 parameters.codecs[1].params[""] = "111/111"; 1697 SetSenderParameters(parameters); 1698 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1699 EXPECT_EQ(111, send_codec_spec.payload_type); 1700 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1701 EXPECT_EQ(std::nullopt, send_codec_spec.red_payload_type); 1702 } 1703 1704 // Test that the RED fmtp line must match the payload type. 1705 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpMismatch) { 1706 EXPECT_TRUE(SetupSendStream()); 1707 webrtc::AudioSenderParameter parameters; 1708 parameters.codecs.push_back(kRed48000Codec); 1709 parameters.codecs[0].params[""] = "8/8"; 1710 parameters.codecs.push_back(kOpusCodec); 1711 SetSenderParameters(parameters); 1712 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1713 EXPECT_EQ(111, send_codec_spec.payload_type); 1714 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1715 EXPECT_EQ(std::nullopt, send_codec_spec.red_payload_type); 1716 } 1717 1718 // Test that the RED fmtp line must show 2..32 payloads. 1719 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsRedFmtpAmountOfRedundancy) { 1720 EXPECT_TRUE(SetupSendStream()); 1721 webrtc::AudioSenderParameter parameters; 1722 parameters.codecs.push_back(kRed48000Codec); 1723 parameters.codecs[0].params[""] = "111"; 1724 parameters.codecs.push_back(kOpusCodec); 1725 SetSenderParameters(parameters); 1726 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1727 EXPECT_EQ(111, send_codec_spec.payload_type); 1728 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1729 EXPECT_EQ(std::nullopt, send_codec_spec.red_payload_type); 1730 for (int i = 1; i < 32; i++) { 1731 parameters.codecs[0].params[""] += "/111"; 1732 SetSenderParameters(parameters); 1733 const auto& send_codec_spec2 = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1734 EXPECT_EQ(111, send_codec_spec2.payload_type); 1735 EXPECT_STRCASEEQ("opus", send_codec_spec2.format.name.c_str()); 1736 EXPECT_EQ(112, send_codec_spec2.red_payload_type); 1737 } 1738 parameters.codecs[0].params[""] += "/111"; 1739 SetSenderParameters(parameters); 1740 const auto& send_codec_spec3 = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1741 EXPECT_EQ(111, send_codec_spec3.payload_type); 1742 EXPECT_STRCASEEQ("opus", send_codec_spec3.format.name.c_str()); 1743 EXPECT_EQ(std::nullopt, send_codec_spec3.red_payload_type); 1744 } 1745 1746 // Test that we use Opus/Red by default if an unknown codec 1747 // is before RED and Opus. 1748 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecRedWithUnknownCodec) { 1749 EXPECT_TRUE(SetupSendStream()); 1750 webrtc::AudioSenderParameter parameters; 1751 parameters.codecs.push_back(kUnknownCodec); 1752 parameters.codecs.push_back(kRed48000Codec); 1753 parameters.codecs.back().params[""] = "111/111"; 1754 parameters.codecs.push_back(kOpusCodec); 1755 SetSenderParameters(parameters); 1756 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1757 EXPECT_EQ(111, send_codec_spec.payload_type); 1758 EXPECT_STRCASEEQ("opus", send_codec_spec.format.name.c_str()); 1759 EXPECT_EQ(112, send_codec_spec.red_payload_type); 1760 } 1761 1762 // Test that WebRtcVoiceEngine reconfigures, rather than recreates its 1763 // AudioSendStream. 1764 TEST_P(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { 1765 EXPECT_TRUE(SetupSendStream()); 1766 webrtc::AudioSenderParameter parameters; 1767 parameters.codecs.push_back(kOpusCodec); 1768 parameters.codecs.push_back(kPcmuCodec); 1769 parameters.codecs.push_back(kCn8000Codec); 1770 parameters.codecs[0].id = 96; 1771 parameters.codecs[0].bitrate = 48000; 1772 const int initial_num = call_.GetNumCreatedSendStreams(); 1773 SetSenderParameters(parameters); 1774 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); 1775 // Calling SetSendCodec again with same codec which is already set. 1776 // In this case media channel shouldn't send codec to VoE. 1777 SetSenderParameters(parameters); 1778 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); 1779 } 1780 1781 // TODO(ossu): Revisit if these tests need to be here, now that these kinds of 1782 // tests should be available in AudioEncoderOpusTest. 1783 1784 // Test that if clockrate is not 48000 for opus, we do not have a send codec. 1785 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { 1786 EXPECT_TRUE(SetupSendStream()); 1787 webrtc::AudioSenderParameter parameters; 1788 parameters.codecs.push_back(kOpusCodec); 1789 parameters.codecs[0].bitrate = 0; 1790 parameters.codecs[0].clockrate = 50000; 1791 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1792 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1793 } 1794 1795 // Test that if channels=0 for opus, we do not have a send codec. 1796 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0ChannelsNoStereo) { 1797 EXPECT_TRUE(SetupSendStream()); 1798 webrtc::AudioSenderParameter parameters; 1799 parameters.codecs.push_back(kOpusCodec); 1800 parameters.codecs[0].bitrate = 0; 1801 parameters.codecs[0].channels = 0; 1802 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1803 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1804 } 1805 1806 // Test that if channels=0 for opus, we do not have a send codec. 1807 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad0Channels1Stereo) { 1808 EXPECT_TRUE(SetupSendStream()); 1809 webrtc::AudioSenderParameter parameters; 1810 parameters.codecs.push_back(kOpusCodec); 1811 parameters.codecs[0].bitrate = 0; 1812 parameters.codecs[0].channels = 0; 1813 parameters.codecs[0].params["stereo"] = "1"; 1814 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1815 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1816 } 1817 1818 // Test that if channel is 1 for opus and there's no stereo, we do not have a 1819 // send codec. 1820 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpus1ChannelNoStereo) { 1821 EXPECT_TRUE(SetupSendStream()); 1822 webrtc::AudioSenderParameter parameters; 1823 parameters.codecs.push_back(kOpusCodec); 1824 parameters.codecs[0].bitrate = 0; 1825 parameters.codecs[0].channels = 1; 1826 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1827 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1828 } 1829 1830 // Test that if channel is 1 for opus and stereo=0, we do not have a send codec. 1831 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel0Stereo) { 1832 EXPECT_TRUE(SetupSendStream()); 1833 webrtc::AudioSenderParameter parameters; 1834 parameters.codecs.push_back(kOpusCodec); 1835 parameters.codecs[0].bitrate = 0; 1836 parameters.codecs[0].channels = 1; 1837 parameters.codecs[0].params["stereo"] = "0"; 1838 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1839 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1840 } 1841 1842 // Test that if channel is 1 for opus and stereo=1, we do not have a send codec. 1843 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { 1844 EXPECT_TRUE(SetupSendStream()); 1845 webrtc::AudioSenderParameter parameters; 1846 parameters.codecs.push_back(kOpusCodec); 1847 parameters.codecs[0].bitrate = 0; 1848 parameters.codecs[0].channels = 1; 1849 parameters.codecs[0].params["stereo"] = "1"; 1850 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 1851 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 1852 } 1853 1854 // Test that with bitrate=0 and no stereo, bitrate is 32000. 1855 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { 1856 EXPECT_TRUE(SetupSendStream()); 1857 webrtc::AudioSenderParameter parameters; 1858 parameters.codecs.push_back(kOpusCodec); 1859 parameters.codecs[0].bitrate = 0; 1860 SetSenderParameters(parameters); 1861 CheckSendCodecBitrate(kSsrcX, "opus", 32000); 1862 } 1863 1864 // Test that with bitrate=0 and stereo=0, bitrate is 32000. 1865 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { 1866 EXPECT_TRUE(SetupSendStream()); 1867 webrtc::AudioSenderParameter parameters; 1868 parameters.codecs.push_back(kOpusCodec); 1869 parameters.codecs[0].bitrate = 0; 1870 parameters.codecs[0].params["stereo"] = "0"; 1871 SetSenderParameters(parameters); 1872 CheckSendCodecBitrate(kSsrcX, "opus", 32000); 1873 } 1874 1875 // Test that with bitrate=invalid and stereo=0, bitrate is 32000. 1876 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { 1877 EXPECT_TRUE(SetupSendStream()); 1878 webrtc::AudioSenderParameter parameters; 1879 parameters.codecs.push_back(kOpusCodec); 1880 parameters.codecs[0].params["stereo"] = "0"; 1881 // bitrate that's out of the range between 6000 and 510000 will be clamped. 1882 parameters.codecs[0].bitrate = 5999; 1883 SetSenderParameters(parameters); 1884 CheckSendCodecBitrate(kSsrcX, "opus", 6000); 1885 1886 parameters.codecs[0].bitrate = 510001; 1887 SetSenderParameters(parameters); 1888 CheckSendCodecBitrate(kSsrcX, "opus", 510000); 1889 } 1890 1891 // Test that with bitrate=0 and stereo=1, bitrate is 64000. 1892 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { 1893 EXPECT_TRUE(SetupSendStream()); 1894 webrtc::AudioSenderParameter parameters; 1895 parameters.codecs.push_back(kOpusCodec); 1896 parameters.codecs[0].bitrate = 0; 1897 parameters.codecs[0].params["stereo"] = "1"; 1898 SetSenderParameters(parameters); 1899 CheckSendCodecBitrate(kSsrcX, "opus", 64000); 1900 } 1901 1902 // Test that with bitrate=invalid and stereo=1, bitrate is 64000. 1903 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { 1904 EXPECT_TRUE(SetupSendStream()); 1905 webrtc::AudioSenderParameter parameters; 1906 parameters.codecs.push_back(kOpusCodec); 1907 parameters.codecs[0].params["stereo"] = "1"; 1908 // bitrate that's out of the range between 6000 and 510000 will be clamped. 1909 parameters.codecs[0].bitrate = 5999; 1910 SetSenderParameters(parameters); 1911 CheckSendCodecBitrate(kSsrcX, "opus", 6000); 1912 1913 parameters.codecs[0].bitrate = 510001; 1914 SetSenderParameters(parameters); 1915 CheckSendCodecBitrate(kSsrcX, "opus", 510000); 1916 } 1917 1918 // Test that with bitrate=N and stereo unset, bitrate is N. 1919 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { 1920 EXPECT_TRUE(SetupSendStream()); 1921 webrtc::AudioSenderParameter parameters; 1922 parameters.codecs.push_back(kOpusCodec); 1923 parameters.codecs[0].bitrate = 96000; 1924 SetSenderParameters(parameters); 1925 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 1926 EXPECT_EQ(111, spec.payload_type); 1927 EXPECT_EQ(96000, spec.target_bitrate_bps); 1928 EXPECT_EQ("opus", spec.format.name); 1929 EXPECT_EQ(2u, spec.format.num_channels); 1930 EXPECT_EQ(48000, spec.format.clockrate_hz); 1931 } 1932 1933 // Test that with bitrate=N and stereo=0, bitrate is N. 1934 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { 1935 EXPECT_TRUE(SetupSendStream()); 1936 webrtc::AudioSenderParameter parameters; 1937 parameters.codecs.push_back(kOpusCodec); 1938 parameters.codecs[0].bitrate = 30000; 1939 parameters.codecs[0].params["stereo"] = "0"; 1940 SetSenderParameters(parameters); 1941 CheckSendCodecBitrate(kSsrcX, "opus", 30000); 1942 } 1943 1944 // Test that with bitrate=N and without any parameters, bitrate is N. 1945 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { 1946 EXPECT_TRUE(SetupSendStream()); 1947 webrtc::AudioSenderParameter parameters; 1948 parameters.codecs.push_back(kOpusCodec); 1949 parameters.codecs[0].bitrate = 30000; 1950 SetSenderParameters(parameters); 1951 CheckSendCodecBitrate(kSsrcX, "opus", 30000); 1952 } 1953 1954 // Test that with bitrate=N and stereo=1, bitrate is N. 1955 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { 1956 EXPECT_TRUE(SetupSendStream()); 1957 webrtc::AudioSenderParameter parameters; 1958 parameters.codecs.push_back(kOpusCodec); 1959 parameters.codecs[0].bitrate = 30000; 1960 parameters.codecs[0].params["stereo"] = "1"; 1961 SetSenderParameters(parameters); 1962 CheckSendCodecBitrate(kSsrcX, "opus", 30000); 1963 } 1964 1965 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { 1966 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", 1967 200000); 1968 } 1969 1970 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { 1971 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); 1972 } 1973 1974 TEST_P(WebRtcVoiceEngineTestFake, 1975 SetSendCodecsWithoutBitratesUsesCorrectDefaults) { 1976 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "", -1); 1977 } 1978 1979 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCapsMinAndStartBitrate) { 1980 SetSendCodecsShouldWorkForBitrates("-1", 0, "-100", -1, "", -1); 1981 } 1982 1983 TEST_P(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthForAudioDoesntAffectBwe) { 1984 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", 1985 200000); 1986 send_parameters_.max_bandwidth_bps = 100000; 1987 // Setting max bitrate should keep previous min bitrate 1988 // Setting max bitrate should not reset start bitrate. 1989 EXPECT_CALL(*call_.GetMockTransportControllerSend(), 1990 SetSdpBitrateParameters( 1991 AllOf(Field(&BitrateConstraints::min_bitrate_bps, 100000), 1992 Field(&BitrateConstraints::start_bitrate_bps, -1), 1993 Field(&BitrateConstraints::max_bitrate_bps, 200000)))); 1994 SetSenderParameters(send_parameters_); 1995 } 1996 1997 // Test that we can enable NACK with opus as callee. 1998 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { 1999 EXPECT_TRUE(SetupRecvStream()); 2000 webrtc::AudioSenderParameter parameters; 2001 parameters.codecs.push_back(kOpusCodec); 2002 parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam( 2003 webrtc::kRtcpFbParamNack, webrtc::kParamValueEmpty)); 2004 EXPECT_EQ(0, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); 2005 SetSenderParameters(parameters); 2006 // NACK should be enabled even with no send stream. 2007 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); 2008 2009 EXPECT_TRUE( 2010 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 2011 } 2012 2013 // Test that we can enable NACK on receive streams. 2014 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackRecvStreams) { 2015 EXPECT_TRUE(SetupSendStream()); 2016 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2017 webrtc::AudioSenderParameter parameters; 2018 parameters.codecs.push_back(kOpusCodec); 2019 parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam( 2020 webrtc::kRtcpFbParamNack, webrtc::kParamValueEmpty)); 2021 EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); 2022 SetSenderParameters(parameters); 2023 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); 2024 } 2025 2026 // Test that we can disable NACK on receive streams. 2027 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecDisableNackRecvStreams) { 2028 EXPECT_TRUE(SetupSendStream()); 2029 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2030 webrtc::AudioSenderParameter parameters; 2031 parameters.codecs.push_back(kOpusCodec); 2032 parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam( 2033 webrtc::kRtcpFbParamNack, webrtc::kParamValueEmpty)); 2034 SetSenderParameters(parameters); 2035 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); 2036 2037 parameters.codecs.clear(); 2038 parameters.codecs.push_back(kOpusCodec); 2039 SetSenderParameters(parameters); 2040 EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); 2041 } 2042 2043 // Test that NACK is enabled on a new receive stream. 2044 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableNack) { 2045 EXPECT_TRUE(SetupSendStream()); 2046 webrtc::AudioSenderParameter parameters; 2047 parameters.codecs.push_back(kOpusCodec); 2048 parameters.codecs.push_back(kCn16000Codec); 2049 parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam( 2050 webrtc::kRtcpFbParamNack, webrtc::kParamValueEmpty)); 2051 SetSenderParameters(parameters); 2052 2053 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2054 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); 2055 EXPECT_TRUE(AddRecvStream(kSsrcZ)); 2056 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); 2057 } 2058 2059 // Test that we can enable RTCP reduced size mode with opus as callee. 2060 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecEnableRtcpReducedSizeAsCallee) { 2061 EXPECT_TRUE(SetupRecvStream()); 2062 webrtc::AudioSenderParameter parameters; 2063 parameters.codecs.push_back(kOpusCodec); 2064 parameters.rtcp.reduced_size = true; 2065 EXPECT_EQ(webrtc::RtcpMode::kCompound, 2066 GetRecvStreamConfig(kSsrcX).rtp.rtcp_mode); 2067 SetSenderParameters(parameters); 2068 // Reduced size mode should be enabled even with no send stream. 2069 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, 2070 GetRecvStreamConfig(kSsrcX).rtp.rtcp_mode); 2071 2072 EXPECT_TRUE( 2073 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 2074 } 2075 2076 // Test that we can enable RTCP reduced size mode on receive streams. 2077 TEST_P(WebRtcVoiceEngineTestFake, 2078 SetSendCodecEnableRtcpReducedSizeRecvStreams) { 2079 EXPECT_TRUE(SetupSendStream()); 2080 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2081 webrtc::AudioSenderParameter parameters; 2082 parameters.codecs.push_back(kOpusCodec); 2083 parameters.rtcp.reduced_size = true; 2084 EXPECT_EQ(webrtc::RtcpMode::kCompound, 2085 GetRecvStreamConfig(kSsrcY).rtp.rtcp_mode); 2086 SetSenderParameters(parameters); 2087 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, 2088 GetRecvStreamConfig(kSsrcY).rtp.rtcp_mode); 2089 } 2090 2091 // Test that we can disable RTCP reduced size mode on receive streams. 2092 TEST_P(WebRtcVoiceEngineTestFake, 2093 SetSendCodecDisableRtcpReducedSizeRecvStreams) { 2094 EXPECT_TRUE(SetupSendStream()); 2095 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2096 webrtc::AudioSenderParameter parameters; 2097 parameters.codecs.push_back(kOpusCodec); 2098 parameters.rtcp.reduced_size = true; 2099 SetSenderParameters(parameters); 2100 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, 2101 GetRecvStreamConfig(kSsrcY).rtp.rtcp_mode); 2102 2103 parameters.rtcp.reduced_size = false; 2104 SetSenderParameters(parameters); 2105 EXPECT_EQ(webrtc::RtcpMode::kCompound, 2106 GetRecvStreamConfig(kSsrcY).rtp.rtcp_mode); 2107 } 2108 2109 // Test that RTCP reduced size mode is enabled on a new receive stream. 2110 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamEnableRtcpReducedSize) { 2111 EXPECT_TRUE(SetupSendStream()); 2112 webrtc::AudioSenderParameter parameters; 2113 parameters.codecs.push_back(kOpusCodec); 2114 parameters.codecs.push_back(kCn16000Codec); 2115 parameters.rtcp.reduced_size = true; 2116 SetSenderParameters(parameters); 2117 2118 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2119 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, 2120 GetRecvStreamConfig(kSsrcY).rtp.rtcp_mode); 2121 EXPECT_TRUE(AddRecvStream(kSsrcZ)); 2122 EXPECT_EQ(webrtc::RtcpMode::kReducedSize, 2123 GetRecvStreamConfig(kSsrcZ).rtp.rtcp_mode); 2124 } 2125 2126 // Test that we can switch back and forth between Opus and PCMU with CN. 2127 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsOpusPcmuSwitching) { 2128 EXPECT_TRUE(SetupSendStream()); 2129 2130 webrtc::AudioSenderParameter opus_parameters; 2131 opus_parameters.codecs.push_back(kOpusCodec); 2132 SetSenderParameters(opus_parameters); 2133 { 2134 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2135 EXPECT_EQ(111, spec.payload_type); 2136 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); 2137 } 2138 2139 webrtc::AudioSenderParameter pcmu_parameters; 2140 pcmu_parameters.codecs.push_back(kPcmuCodec); 2141 pcmu_parameters.codecs.push_back(kCn16000Codec); 2142 pcmu_parameters.codecs.push_back(kOpusCodec); 2143 SetSenderParameters(pcmu_parameters); 2144 { 2145 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2146 EXPECT_EQ(0, spec.payload_type); 2147 EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); 2148 } 2149 2150 SetSenderParameters(opus_parameters); 2151 { 2152 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2153 EXPECT_EQ(111, spec.payload_type); 2154 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); 2155 } 2156 } 2157 2158 // Test that we handle various ways of specifying bitrate. 2159 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { 2160 EXPECT_TRUE(SetupSendStream()); 2161 webrtc::AudioSenderParameter parameters; 2162 parameters.codecs.push_back(kPcmuCodec); 2163 SetSenderParameters(parameters); 2164 { 2165 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2166 EXPECT_EQ(0, spec.payload_type); 2167 EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); 2168 EXPECT_EQ(64000, spec.target_bitrate_bps); 2169 } 2170 2171 parameters.codecs[0].bitrate = 0; // bitrate == default 2172 SetSenderParameters(parameters); 2173 { 2174 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2175 EXPECT_EQ(0, spec.payload_type); 2176 EXPECT_STREQ("PCMU", spec.format.name.c_str()); 2177 EXPECT_EQ(64000, spec.target_bitrate_bps); 2178 } 2179 2180 parameters.codecs[0] = kOpusCodec; 2181 parameters.codecs[0].bitrate = 0; // bitrate == default 2182 SetSenderParameters(parameters); 2183 { 2184 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2185 EXPECT_EQ(111, spec.payload_type); 2186 EXPECT_STREQ("opus", spec.format.name.c_str()); 2187 EXPECT_EQ(32000, spec.target_bitrate_bps); 2188 } 2189 } 2190 2191 // Test that we do not fail if no codecs are specified. 2192 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { 2193 EXPECT_TRUE(SetupSendStream()); 2194 webrtc::AudioSenderParameter parameters; 2195 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters)); 2196 EXPECT_EQ(send_channel_->GetSendCodec(), std::nullopt); 2197 } 2198 2199 // Test that we can set send codecs even with telephone-event codec as the first 2200 // one on the list. 2201 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { 2202 EXPECT_TRUE(SetupSendStream()); 2203 webrtc::AudioSenderParameter parameters; 2204 parameters.codecs.push_back(kTelephoneEventCodec1); 2205 parameters.codecs.push_back(kOpusCodec); 2206 parameters.codecs.push_back(kPcmuCodec); 2207 parameters.codecs[0].id = 98; // DTMF 2208 parameters.codecs[1].id = 96; 2209 SetSenderParameters(parameters); 2210 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2211 EXPECT_EQ(96, spec.payload_type); 2212 EXPECT_STRCASEEQ("OPUS", spec.format.name.c_str()); 2213 SetSend(true); 2214 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2215 } 2216 2217 // Test that CanInsertDtmf() is governed by the send flag 2218 TEST_P(WebRtcVoiceEngineTestFake, DTMFControlledBySendFlag) { 2219 EXPECT_TRUE(SetupSendStream()); 2220 webrtc::AudioSenderParameter parameters; 2221 parameters.codecs.push_back(kTelephoneEventCodec1); 2222 parameters.codecs.push_back(kPcmuCodec); 2223 parameters.codecs[0].id = 98; // DTMF 2224 parameters.codecs[1].id = 96; 2225 SetSenderParameters(parameters); 2226 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 2227 SetSend(true); 2228 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2229 SetSend(false); 2230 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 2231 } 2232 2233 // Test that payload type range is limited for telephone-event codec. 2234 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { 2235 EXPECT_TRUE(SetupSendStream()); 2236 webrtc::AudioSenderParameter parameters; 2237 parameters.codecs.push_back(kTelephoneEventCodec2); 2238 parameters.codecs.push_back(kOpusCodec); 2239 parameters.codecs[0].id = 0; // DTMF 2240 parameters.codecs[1].id = 96; 2241 SetSenderParameters(parameters); 2242 SetSend(true); 2243 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2244 parameters.codecs[0].id = 128; // DTMF 2245 EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); 2246 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 2247 parameters.codecs[0].id = 127; 2248 SetSenderParameters(parameters); 2249 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2250 parameters.codecs[0].id = -1; // DTMF 2251 EXPECT_FALSE(send_channel_->SetSenderParameters(parameters)); 2252 EXPECT_FALSE(send_channel_->CanInsertDtmf()); 2253 } 2254 2255 // Test that we can set send codecs even with CN codec as the first 2256 // one on the list. 2257 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { 2258 EXPECT_TRUE(SetupSendStream()); 2259 webrtc::AudioSenderParameter parameters; 2260 parameters.codecs.push_back(kCn8000Codec); 2261 parameters.codecs.push_back(kPcmuCodec); 2262 parameters.codecs[0].id = 98; // narrowband CN 2263 SetSenderParameters(parameters); 2264 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2265 EXPECT_EQ(0, send_codec_spec.payload_type); 2266 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2267 EXPECT_EQ(98, send_codec_spec.cng_payload_type); 2268 } 2269 2270 // Test that we set VAD and DTMF types correctly as caller. 2271 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { 2272 EXPECT_TRUE(SetupSendStream()); 2273 webrtc::AudioSenderParameter parameters; 2274 parameters.codecs.push_back(kPcmuCodec); 2275 parameters.codecs.push_back(kCn16000Codec); 2276 parameters.codecs.push_back(kCn8000Codec); 2277 parameters.codecs.push_back(kTelephoneEventCodec1); 2278 parameters.codecs[0].id = 96; 2279 parameters.codecs[2].id = 97; // narrowband CN 2280 parameters.codecs[3].id = 98; // DTMF 2281 SetSenderParameters(parameters); 2282 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2283 EXPECT_EQ(96, send_codec_spec.payload_type); 2284 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2285 EXPECT_EQ(1u, send_codec_spec.format.num_channels); 2286 EXPECT_EQ(97, send_codec_spec.cng_payload_type); 2287 SetSend(true); 2288 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2289 } 2290 2291 // Test that we set VAD and DTMF types correctly as callee. 2292 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { 2293 EXPECT_TRUE(SetupChannel()); 2294 webrtc::AudioSenderParameter parameters; 2295 parameters.codecs.push_back(kPcmuCodec); 2296 parameters.codecs.push_back(kCn16000Codec); 2297 parameters.codecs.push_back(kCn8000Codec); 2298 parameters.codecs.push_back(kTelephoneEventCodec2); 2299 parameters.codecs[0].id = 96; 2300 parameters.codecs[2].id = 97; // narrowband CN 2301 parameters.codecs[3].id = 98; // DTMF 2302 SetSenderParameters(parameters); 2303 EXPECT_TRUE( 2304 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 2305 2306 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2307 EXPECT_EQ(96, send_codec_spec.payload_type); 2308 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2309 EXPECT_EQ(1u, send_codec_spec.format.num_channels); 2310 EXPECT_EQ(97, send_codec_spec.cng_payload_type); 2311 SetSend(true); 2312 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2313 } 2314 2315 // Test that we only apply VAD if we have a CN codec that matches the 2316 // send codec clockrate. 2317 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { 2318 EXPECT_TRUE(SetupSendStream()); 2319 webrtc::AudioSenderParameter parameters; 2320 // Set PCMU(8K) and CN(16K). VAD should not be activated. 2321 parameters.codecs.push_back(kPcmuCodec); 2322 parameters.codecs.push_back(kCn16000Codec); 2323 parameters.codecs[1].id = 97; 2324 SetSenderParameters(parameters); 2325 { 2326 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2327 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2328 EXPECT_EQ(std::nullopt, send_codec_spec.cng_payload_type); 2329 } 2330 // Set PCMU(8K) and CN(8K). VAD should be activated. 2331 parameters.codecs[1] = kCn8000Codec; 2332 SetSenderParameters(parameters); 2333 { 2334 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2335 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2336 EXPECT_EQ(1u, send_codec_spec.format.num_channels); 2337 EXPECT_EQ(13, send_codec_spec.cng_payload_type); 2338 } 2339 // Set OPUS(48K) and CN(8K). VAD should not be activated. 2340 parameters.codecs[0] = kOpusCodec; 2341 SetSenderParameters(parameters); 2342 { 2343 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2344 EXPECT_STRCASEEQ("OPUS", send_codec_spec.format.name.c_str()); 2345 EXPECT_EQ(std::nullopt, send_codec_spec.cng_payload_type); 2346 } 2347 } 2348 2349 // Test that we perform case-insensitive matching of codec names. 2350 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { 2351 EXPECT_TRUE(SetupSendStream()); 2352 webrtc::AudioSenderParameter parameters; 2353 parameters.codecs.push_back(kPcmuCodec); 2354 parameters.codecs.push_back(kCn16000Codec); 2355 parameters.codecs.push_back(kCn8000Codec); 2356 parameters.codecs.push_back(kTelephoneEventCodec1); 2357 parameters.codecs[0].name = "PcMu"; 2358 parameters.codecs[0].id = 96; 2359 parameters.codecs[2].id = 97; // narrowband CN 2360 parameters.codecs[3].id = 98; // DTMF 2361 SetSenderParameters(parameters); 2362 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; 2363 EXPECT_EQ(96, send_codec_spec.payload_type); 2364 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2365 EXPECT_EQ(1u, send_codec_spec.format.num_channels); 2366 EXPECT_EQ(97, send_codec_spec.cng_payload_type); 2367 SetSend(true); 2368 EXPECT_TRUE(send_channel_->CanInsertDtmf()); 2369 } 2370 2371 TEST_P(WebRtcVoiceEngineTestFake, 2372 SupportsTransportSequenceNumberHeaderExtension) { 2373 const std::vector<webrtc::RtpExtension> header_extensions = 2374 webrtc::GetDefaultEnabledRtpHeaderExtensions(*engine_, 2375 /* field_trials= */ nullptr); 2376 EXPECT_THAT(header_extensions, 2377 Contains(::testing::Field( 2378 "uri", &webrtc::RtpExtension::uri, 2379 webrtc::RtpExtension::kTransportSequenceNumberUri))); 2380 } 2381 2382 // Test support for audio level header extension. 2383 TEST_P(WebRtcVoiceEngineTestFake, SendAudioLevelHeaderExtensions) { 2384 TestSetSendRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri); 2385 } 2386 TEST_P(WebRtcVoiceEngineTestFake, RecvAudioLevelHeaderExtensions) { 2387 TestSetRecvRtpHeaderExtensions(webrtc::RtpExtension::kAudioLevelUri); 2388 } 2389 2390 // Test support for transport sequence number header extension. 2391 TEST_P(WebRtcVoiceEngineTestFake, SendTransportSequenceNumberHeaderExtensions) { 2392 TestSetSendRtpHeaderExtensions( 2393 webrtc::RtpExtension::kTransportSequenceNumberUri); 2394 } 2395 TEST_P(WebRtcVoiceEngineTestFake, RecvTransportSequenceNumberHeaderExtensions) { 2396 TestSetRecvRtpHeaderExtensions( 2397 webrtc::RtpExtension::kTransportSequenceNumberUri); 2398 } 2399 2400 // Test that we can create a channel and start sending on it. 2401 TEST_P(WebRtcVoiceEngineTestFake, Send) { 2402 EXPECT_TRUE(SetupSendStream()); 2403 SetSenderParameters(send_parameters_); 2404 SetSend(true); 2405 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 2406 SetSend(false); 2407 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 2408 } 2409 2410 // Test that a channel is muted/unmuted. 2411 TEST_P(WebRtcVoiceEngineTestFake, SendStateMuteUnmute) { 2412 EXPECT_TRUE(SetupSendStream()); 2413 SetSenderParameters(send_parameters_); 2414 EXPECT_FALSE(GetSendStream(kSsrcX).muted()); 2415 SetAudioSend(kSsrcX, true, nullptr); 2416 EXPECT_FALSE(GetSendStream(kSsrcX).muted()); 2417 SetAudioSend(kSsrcX, false, nullptr); 2418 EXPECT_TRUE(GetSendStream(kSsrcX).muted()); 2419 } 2420 2421 // Test that SetSenderParameters() does not alter a stream's send state. 2422 TEST_P(WebRtcVoiceEngineTestFake, SendStateWhenStreamsAreRecreated) { 2423 EXPECT_TRUE(SetupSendStream()); 2424 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 2425 2426 // Turn on sending. 2427 SetSend(true); 2428 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 2429 2430 // Changing RTP header extensions will recreate the AudioSendStream. 2431 send_parameters_.extensions.push_back( 2432 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); 2433 SetSenderParameters(send_parameters_); 2434 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 2435 2436 // Turn off sending. 2437 SetSend(false); 2438 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 2439 2440 // Changing RTP header extensions will recreate the AudioSendStream. 2441 send_parameters_.extensions.clear(); 2442 SetSenderParameters(send_parameters_); 2443 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 2444 } 2445 2446 // Test that we can create a channel and start playing out on it. 2447 TEST_P(WebRtcVoiceEngineTestFake, Playout) { 2448 EXPECT_TRUE(SetupRecvStream()); 2449 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 2450 receive_channel_->SetPlayout(true); 2451 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); 2452 receive_channel_->SetPlayout(false); 2453 EXPECT_FALSE(GetRecvStream(kSsrcX).started()); 2454 } 2455 2456 // Test that we can add and remove send streams. 2457 TEST_P(WebRtcVoiceEngineTestFake, CreateAndDeleteMultipleSendStreams) { 2458 SetupForMultiSendStream(); 2459 2460 // Set the global state for sending. 2461 SetSend(true); 2462 2463 for (uint32_t ssrc : kSsrcs4) { 2464 EXPECT_TRUE( 2465 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(ssrc))); 2466 SetAudioSend(ssrc, true, &fake_source_); 2467 // Verify that we are in a sending state for all the created streams. 2468 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); 2469 } 2470 EXPECT_EQ(std::size(kSsrcs4), call_.GetAudioSendStreams().size()); 2471 2472 // Delete the send streams. 2473 for (uint32_t ssrc : kSsrcs4) { 2474 EXPECT_TRUE(send_channel_->RemoveSendStream(ssrc)); 2475 EXPECT_FALSE(call_.GetAudioSendStream(ssrc)); 2476 EXPECT_FALSE(send_channel_->RemoveSendStream(ssrc)); 2477 } 2478 EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); 2479 } 2480 2481 // Test SetSendCodecs correctly configure the codecs in all send streams. 2482 TEST_P(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) { 2483 SetupForMultiSendStream(); 2484 2485 // Create send streams. 2486 for (uint32_t ssrc : kSsrcs4) { 2487 EXPECT_TRUE( 2488 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(ssrc))); 2489 } 2490 2491 webrtc::AudioSenderParameter parameters; 2492 // Set PCMU and CN(8K). VAD should be activated. 2493 parameters.codecs.push_back(kPcmuCodec); 2494 parameters.codecs.push_back(kCn8000Codec); 2495 parameters.codecs[1].id = 97; 2496 SetSenderParameters(parameters); 2497 2498 // Verify PCMU and VAD are corrected configured on all send channels. 2499 for (uint32_t ssrc : kSsrcs4) { 2500 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); 2501 const auto& send_codec_spec = 2502 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; 2503 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2504 EXPECT_EQ(1u, send_codec_spec.format.num_channels); 2505 EXPECT_EQ(97, send_codec_spec.cng_payload_type); 2506 } 2507 2508 // Change to PCMU(8K) and CN(16K). 2509 parameters.codecs[0] = kPcmuCodec; 2510 parameters.codecs[1] = kCn16000Codec; 2511 SetSenderParameters(parameters); 2512 for (uint32_t ssrc : kSsrcs4) { 2513 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); 2514 const auto& send_codec_spec = 2515 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; 2516 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); 2517 EXPECT_EQ(std::nullopt, send_codec_spec.cng_payload_type); 2518 } 2519 } 2520 2521 // Test we can SetSend on all send streams correctly. 2522 TEST_P(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { 2523 SetupForMultiSendStream(); 2524 2525 // Create the send channels and they should be a "not sending" date. 2526 for (uint32_t ssrc : kSsrcs4) { 2527 EXPECT_TRUE( 2528 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(ssrc))); 2529 SetAudioSend(ssrc, true, &fake_source_); 2530 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); 2531 } 2532 2533 // Set the global state for starting sending. 2534 SetSend(true); 2535 for (uint32_t ssrc : kSsrcs4) { 2536 // Verify that we are in a sending state for all the send streams. 2537 EXPECT_TRUE(GetSendStream(ssrc).IsSending()); 2538 } 2539 2540 // Set the global state for stopping sending. 2541 SetSend(false); 2542 for (uint32_t ssrc : kSsrcs4) { 2543 // Verify that we are in a stop state for all the send streams. 2544 EXPECT_FALSE(GetSendStream(ssrc).IsSending()); 2545 } 2546 } 2547 2548 // Test we can set the correct statistics on all send streams. 2549 TEST_P(WebRtcVoiceEngineTestFake, GetStatsWithMultipleSendStreams) { 2550 SetupForMultiSendStream(); 2551 2552 // Create send streams. 2553 for (uint32_t ssrc : kSsrcs4) { 2554 EXPECT_TRUE( 2555 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(ssrc))); 2556 } 2557 2558 // Create a receive stream to check that none of the send streams end up in 2559 // the receive stream stats. 2560 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2561 2562 // We need send codec to be set to get all stats. 2563 SetSenderParameters(send_parameters_); 2564 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 2565 SetAudioSendStreamStats(); 2566 SetAudioReceiveStreamStats(); 2567 2568 // Check stats for the added streams. 2569 { 2570 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2571 webrtc::VoiceMediaSendInfo send_info; 2572 webrtc::VoiceMediaReceiveInfo receive_info; 2573 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2574 EXPECT_EQ(true, receive_channel_->GetStats( 2575 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2576 2577 // We have added 4 send streams. We should see empty stats for all. 2578 EXPECT_EQ(std::size(kSsrcs4), send_info.senders.size()); 2579 for (const auto& sender : send_info.senders) { 2580 VerifyVoiceSenderInfo(sender, false); 2581 } 2582 VerifyVoiceSendRecvCodecs(send_info, receive_info); 2583 2584 // We have added one receive stream. We should see empty stats. 2585 EXPECT_EQ(receive_info.receivers.size(), 1u); 2586 EXPECT_EQ(receive_info.receivers[0].ssrc(), 123u); 2587 } 2588 2589 // Remove the kSsrcY stream. No receiver stats. 2590 { 2591 webrtc::VoiceMediaReceiveInfo receive_info; 2592 webrtc::VoiceMediaSendInfo send_info; 2593 EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY)); 2594 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2595 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2596 EXPECT_EQ(true, receive_channel_->GetStats( 2597 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2598 EXPECT_EQ(std::size(kSsrcs4), send_info.senders.size()); 2599 EXPECT_EQ(0u, receive_info.receivers.size()); 2600 } 2601 2602 // Deliver a new packet - a default receive stream should be created and we 2603 // should see stats again. 2604 { 2605 webrtc::VoiceMediaSendInfo send_info; 2606 webrtc::VoiceMediaReceiveInfo receive_info; 2607 DeliverPacket(kPcmuFrame); 2608 SetAudioReceiveStreamStats(); 2609 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2610 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2611 EXPECT_EQ(true, receive_channel_->GetStats( 2612 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2613 EXPECT_EQ(std::size(kSsrcs4), send_info.senders.size()); 2614 EXPECT_EQ(1u, receive_info.receivers.size()); 2615 VerifyVoiceReceiverInfo(receive_info.receivers[0]); 2616 VerifyVoiceSendRecvCodecs(send_info, receive_info); 2617 } 2618 } 2619 2620 // Test that we can add and remove receive streams, and do proper send/playout. 2621 // We can receive on multiple streams while sending one stream. 2622 TEST_P(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) { 2623 EXPECT_TRUE(SetupSendStream()); 2624 2625 // Start playout without a receive stream. 2626 SetSenderParameters(send_parameters_); 2627 receive_channel_->SetPlayout(true); 2628 2629 // Adding another stream should enable playout on the new stream only. 2630 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2631 SetSend(true); 2632 EXPECT_TRUE(GetSendStream(kSsrcX).IsSending()); 2633 2634 // Make sure only the new stream is played out. 2635 EXPECT_TRUE(GetRecvStream(kSsrcY).started()); 2636 2637 // Adding yet another stream should have stream 2 and 3 enabled for playout. 2638 EXPECT_TRUE(AddRecvStream(kSsrcZ)); 2639 EXPECT_TRUE(GetRecvStream(kSsrcY).started()); 2640 EXPECT_TRUE(GetRecvStream(kSsrcZ).started()); 2641 2642 // Stop sending. 2643 SetSend(false); 2644 EXPECT_FALSE(GetSendStream(kSsrcX).IsSending()); 2645 2646 // Stop playout. 2647 receive_channel_->SetPlayout(false); 2648 EXPECT_FALSE(GetRecvStream(kSsrcY).started()); 2649 EXPECT_FALSE(GetRecvStream(kSsrcZ).started()); 2650 2651 // Restart playout and make sure recv streams are played out. 2652 receive_channel_->SetPlayout(true); 2653 EXPECT_TRUE(GetRecvStream(kSsrcY).started()); 2654 EXPECT_TRUE(GetRecvStream(kSsrcZ).started()); 2655 2656 // Now remove the recv streams. 2657 EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcZ)); 2658 EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY)); 2659 } 2660 2661 TEST_P(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) { 2662 EXPECT_TRUE(SetupSendStream()); 2663 send_parameters_.options.audio_network_adaptor = true; 2664 send_parameters_.options.audio_network_adaptor_config = {"1234"}; 2665 SetSenderParameters(send_parameters_); 2666 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 2667 GetAudioNetworkAdaptorConfig(kSsrcX)); 2668 } 2669 2670 TEST_P(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { 2671 EXPECT_TRUE(SetupSendStream()); 2672 send_parameters_.options.audio_network_adaptor = true; 2673 send_parameters_.options.audio_network_adaptor_config = {"1234"}; 2674 SetSenderParameters(send_parameters_); 2675 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 2676 GetAudioNetworkAdaptorConfig(kSsrcX)); 2677 webrtc::AudioOptions options; 2678 options.audio_network_adaptor = false; 2679 SetAudioSend(kSsrcX, true, nullptr, &options); 2680 EXPECT_EQ(std::nullopt, GetAudioNetworkAdaptorConfig(kSsrcX)); 2681 } 2682 2683 TEST_P(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { 2684 EXPECT_TRUE(SetupSendStream()); 2685 send_parameters_.options.audio_network_adaptor = true; 2686 send_parameters_.options.audio_network_adaptor_config = {"1234"}; 2687 SetSenderParameters(send_parameters_); 2688 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 2689 GetAudioNetworkAdaptorConfig(kSsrcX)); 2690 const int initial_num = call_.GetNumCreatedSendStreams(); 2691 webrtc::AudioOptions options; 2692 options.audio_network_adaptor = std::nullopt; 2693 // Unvalued `options.audio_network_adaptor` should not reset audio network 2694 // adaptor. 2695 SetAudioSend(kSsrcX, true, nullptr, &options); 2696 // AudioSendStream not expected to be recreated. 2697 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); 2698 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, 2699 GetAudioNetworkAdaptorConfig(kSsrcX)); 2700 } 2701 2702 // Test that we can set the outgoing SSRC properly. 2703 // SSRC is set in SetupSendStream() by calling AddSendStream. 2704 TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrc) { 2705 EXPECT_TRUE(SetupSendStream()); 2706 EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX)); 2707 } 2708 2709 TEST_P(WebRtcVoiceEngineTestFake, GetStats) { 2710 // Setup. We need send codec to be set to get all stats. 2711 EXPECT_TRUE(SetupSendStream()); 2712 // SetupSendStream adds a send stream with kSsrcX, so the receive 2713 // stream has to use a different SSRC. 2714 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2715 SetSenderParameters(send_parameters_); 2716 EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_)); 2717 SetAudioSendStreamStats(); 2718 2719 // Check stats for the added streams. 2720 { 2721 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2722 webrtc::VoiceMediaSendInfo send_info; 2723 webrtc::VoiceMediaReceiveInfo receive_info; 2724 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2725 EXPECT_EQ(true, receive_channel_->GetStats( 2726 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2727 2728 // We have added one send stream. We should see the stats we've set. 2729 EXPECT_EQ(1u, send_info.senders.size()); 2730 VerifyVoiceSenderInfo(send_info.senders[0], false); 2731 // We have added one receive stream. We should see empty stats. 2732 EXPECT_EQ(receive_info.receivers.size(), 1u); 2733 EXPECT_EQ(receive_info.receivers[0].ssrc(), 0u); 2734 } 2735 2736 // Start sending - this affects some reported stats. 2737 { 2738 SetSend(true); 2739 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2740 webrtc::VoiceMediaSendInfo send_info; 2741 webrtc::VoiceMediaReceiveInfo receive_info; 2742 SetAudioReceiveStreamStats(); 2743 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2744 EXPECT_EQ(true, receive_channel_->GetStats( 2745 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2746 VerifyVoiceSenderInfo(send_info.senders[0], true); 2747 VerifyVoiceSendRecvCodecs(send_info, receive_info); 2748 } 2749 2750 // Remove the kSsrcY stream. No receiver stats. 2751 { 2752 EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrcY)); 2753 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2754 webrtc::VoiceMediaSendInfo send_info; 2755 webrtc::VoiceMediaReceiveInfo receive_info; 2756 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2757 EXPECT_EQ(true, receive_channel_->GetStats( 2758 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2759 EXPECT_EQ(1u, send_info.senders.size()); 2760 EXPECT_EQ(0u, receive_info.receivers.size()); 2761 } 2762 2763 // Deliver a new packet - a default receive stream should be created and we 2764 // should see stats again. 2765 { 2766 DeliverPacket(kPcmuFrame); 2767 SetAudioReceiveStreamStats(); 2768 EXPECT_CALL(*adm_, GetPlayoutUnderrunCount()).WillOnce(Return(0)); 2769 webrtc::VoiceMediaSendInfo send_info; 2770 webrtc::VoiceMediaReceiveInfo receive_info; 2771 EXPECT_EQ(true, send_channel_->GetStats(&send_info)); 2772 EXPECT_EQ(true, receive_channel_->GetStats( 2773 &receive_info, /*get_and_clear_legacy_stats=*/true)); 2774 EXPECT_EQ(1u, send_info.senders.size()); 2775 EXPECT_EQ(1u, receive_info.receivers.size()); 2776 VerifyVoiceReceiverInfo(receive_info.receivers[0]); 2777 VerifyVoiceSendRecvCodecs(send_info, receive_info); 2778 } 2779 } 2780 2781 // Test that we can set the outgoing SSRC properly with multiple streams. 2782 // SSRC is set in SetupSendStream() by calling AddSendStream. 2783 TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrcWithMultipleStreams) { 2784 EXPECT_TRUE(SetupSendStream()); 2785 EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX)); 2786 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2787 EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).rtp.local_ssrc); 2788 } 2789 2790 // Test that the local SSRC is the same on sending and receiving channels if the 2791 // receive channel is created before the send channel. 2792 TEST_P(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) { 2793 EXPECT_TRUE(SetupChannel()); 2794 EXPECT_TRUE(AddRecvStream(kSsrcY)); 2795 EXPECT_TRUE( 2796 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcX))); 2797 EXPECT_TRUE(call_.GetAudioSendStream(kSsrcX)); 2798 EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).rtp.local_ssrc); 2799 } 2800 2801 // Test that we can properly receive packets. 2802 TEST_P(WebRtcVoiceEngineTestFake, Recv) { 2803 EXPECT_TRUE(SetupChannel()); 2804 EXPECT_TRUE(AddRecvStream(1)); 2805 DeliverPacket(kPcmuFrame); 2806 2807 EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame)); 2808 } 2809 2810 // Test that we can properly receive packets on multiple streams. 2811 TEST_P(WebRtcVoiceEngineTestFake, RecvWithMultipleStreams) { 2812 EXPECT_TRUE(SetupChannel()); 2813 const uint32_t ssrc1 = 1; 2814 const uint32_t ssrc2 = 2; 2815 const uint32_t ssrc3 = 3; 2816 EXPECT_TRUE(AddRecvStream(ssrc1)); 2817 EXPECT_TRUE(AddRecvStream(ssrc2)); 2818 EXPECT_TRUE(AddRecvStream(ssrc3)); 2819 // Create packets with the right SSRCs. 2820 uint8_t packets[4][sizeof(kPcmuFrame)]; 2821 for (size_t i = 0; i < std::size(packets); ++i) { 2822 memcpy(packets[i], kPcmuFrame, sizeof(kPcmuFrame)); 2823 webrtc::SetBE32(packets[i] + 8, static_cast<uint32_t>(i)); 2824 } 2825 2826 const webrtc::FakeAudioReceiveStream& s1 = GetRecvStream(ssrc1); 2827 const webrtc::FakeAudioReceiveStream& s2 = GetRecvStream(ssrc2); 2828 const webrtc::FakeAudioReceiveStream& s3 = GetRecvStream(ssrc3); 2829 2830 EXPECT_EQ(s1.received_packets(), 0); 2831 EXPECT_EQ(s2.received_packets(), 0); 2832 EXPECT_EQ(s3.received_packets(), 0); 2833 2834 DeliverPacket(packets[0]); 2835 EXPECT_EQ(s1.received_packets(), 0); 2836 EXPECT_EQ(s2.received_packets(), 0); 2837 EXPECT_EQ(s3.received_packets(), 0); 2838 2839 DeliverPacket(packets[1]); 2840 EXPECT_EQ(s1.received_packets(), 1); 2841 EXPECT_TRUE(s1.VerifyLastPacket(packets[1])); 2842 EXPECT_EQ(s2.received_packets(), 0); 2843 EXPECT_EQ(s3.received_packets(), 0); 2844 2845 DeliverPacket(packets[2]); 2846 EXPECT_EQ(s1.received_packets(), 1); 2847 EXPECT_EQ(s2.received_packets(), 1); 2848 EXPECT_TRUE(s2.VerifyLastPacket(packets[2])); 2849 EXPECT_EQ(s3.received_packets(), 0); 2850 2851 DeliverPacket(packets[3]); 2852 EXPECT_EQ(s1.received_packets(), 1); 2853 EXPECT_EQ(s2.received_packets(), 1); 2854 EXPECT_EQ(s3.received_packets(), 1); 2855 EXPECT_TRUE(s3.VerifyLastPacket(packets[3])); 2856 2857 EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc3)); 2858 EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc2)); 2859 EXPECT_TRUE(receive_channel_->RemoveRecvStream(ssrc1)); 2860 } 2861 2862 // Test that receiving on an unsignaled stream works (a stream is created). 2863 TEST_P(WebRtcVoiceEngineTestFake, RecvUnsignaled) { 2864 EXPECT_TRUE(SetupChannel()); 2865 EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size()); 2866 2867 DeliverPacket(kPcmuFrame); 2868 2869 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 2870 EXPECT_TRUE(GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame)); 2871 } 2872 2873 // Tests that when we add a stream without SSRCs, but contains a stream_id 2874 // that it is stored and its stream id is later used when the first packet 2875 // arrives to properly create a receive stream with a sync label. 2876 TEST_P(WebRtcVoiceEngineTestFake, RecvUnsignaledSsrcWithSignaledStreamId) { 2877 const char kSyncLabel[] = "sync_label"; 2878 EXPECT_TRUE(SetupChannel()); 2879 webrtc::StreamParams unsignaled_stream; 2880 unsignaled_stream.set_stream_ids({kSyncLabel}); 2881 ASSERT_TRUE(receive_channel_->AddRecvStream(unsignaled_stream)); 2882 // The stream shouldn't have been created at this point because it doesn't 2883 // have any SSRCs. 2884 EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size()); 2885 DeliverPacket(kPcmuFrame); 2886 2887 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 2888 EXPECT_TRUE(GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame)); 2889 EXPECT_EQ(kSyncLabel, GetRecvStream(kSsrc1).GetConfig().sync_group); 2890 2891 // Remset the unsignaled stream to clear the cached parameters. If a new 2892 // default unsignaled receive stream is created it will not have a sync group. 2893 receive_channel_->ResetUnsignaledRecvStream(); 2894 receive_channel_->RemoveRecvStream(kSsrc1); 2895 2896 DeliverPacket(kPcmuFrame); 2897 2898 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 2899 EXPECT_TRUE(GetRecvStream(kSsrc1).VerifyLastPacket(kPcmuFrame)); 2900 EXPECT_TRUE(GetRecvStream(kSsrc1).GetConfig().sync_group.empty()); 2901 } 2902 2903 TEST_P(WebRtcVoiceEngineTestFake, 2904 ResetUnsignaledRecvStreamDeletesAllDefaultStreams) { 2905 ASSERT_TRUE(SetupChannel()); 2906 // No receive streams to start with. 2907 ASSERT_TRUE(call_.GetAudioReceiveStreams().empty()); 2908 2909 // Deliver a couple packets with unsignaled SSRCs. 2910 uint8_t packet[sizeof(kPcmuFrame)]; 2911 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); 2912 webrtc::SetBE32(&packet[8], 0x1234); 2913 DeliverPacket(packet); 2914 webrtc::SetBE32(&packet[8], 0x5678); 2915 DeliverPacket(packet); 2916 2917 // Verify that the receive streams were created. 2918 const auto& receivers1 = call_.GetAudioReceiveStreams(); 2919 ASSERT_EQ(receivers1.size(), 2u); 2920 2921 // Should remove all default streams. 2922 receive_channel_->ResetUnsignaledRecvStream(); 2923 const auto& receivers2 = call_.GetAudioReceiveStreams(); 2924 EXPECT_EQ(0u, receivers2.size()); 2925 } 2926 2927 // Test that receiving N unsignaled stream works (streams will be created), and 2928 // that packets are forwarded to them all. 2929 TEST_P(WebRtcVoiceEngineTestFake, RecvMultipleUnsignaled) { 2930 EXPECT_TRUE(SetupChannel()); 2931 uint8_t packet[sizeof(kPcmuFrame)]; 2932 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); 2933 2934 // Note that SSRC = 0 is not supported. 2935 for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledRecvStreams); ++ssrc) { 2936 webrtc::SetBE32(&packet[8], ssrc); 2937 DeliverPacket(packet); 2938 2939 // Verify we have one new stream for each loop iteration. 2940 EXPECT_EQ(ssrc, call_.GetAudioReceiveStreams().size()); 2941 EXPECT_EQ(1, GetRecvStream(ssrc).received_packets()); 2942 EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet)); 2943 } 2944 2945 // Sending on the same SSRCs again should not create new streams. 2946 for (uint32_t ssrc = 1; ssrc < (1 + kMaxUnsignaledRecvStreams); ++ssrc) { 2947 webrtc::SetBE32(&packet[8], ssrc); 2948 DeliverPacket(packet); 2949 2950 EXPECT_EQ(kMaxUnsignaledRecvStreams, call_.GetAudioReceiveStreams().size()); 2951 EXPECT_EQ(2, GetRecvStream(ssrc).received_packets()); 2952 EXPECT_TRUE(GetRecvStream(ssrc).VerifyLastPacket(packet)); 2953 } 2954 2955 // Send on another SSRC, the oldest unsignaled stream (SSRC=1) is replaced. 2956 constexpr uint32_t kAnotherSsrc = 667; 2957 webrtc::SetBE32(&packet[8], kAnotherSsrc); 2958 DeliverPacket(packet); 2959 2960 const auto& streams = call_.GetAudioReceiveStreams(); 2961 EXPECT_EQ(kMaxUnsignaledRecvStreams, streams.size()); 2962 size_t i = 0; 2963 for (uint32_t ssrc = 2; ssrc < (1 + kMaxUnsignaledRecvStreams); ++ssrc, ++i) { 2964 EXPECT_EQ(ssrc, streams[i]->GetConfig().rtp.remote_ssrc); 2965 EXPECT_EQ(2, streams[i]->received_packets()); 2966 } 2967 EXPECT_EQ(kAnotherSsrc, streams[i]->GetConfig().rtp.remote_ssrc); 2968 EXPECT_EQ(1, streams[i]->received_packets()); 2969 // Sanity check that we've checked all streams. 2970 EXPECT_EQ(kMaxUnsignaledRecvStreams, (i + 1)); 2971 } 2972 2973 // Test that a default channel is created even after a signaled stream has been 2974 // added, and that this stream will get any packets for unknown SSRCs. 2975 TEST_P(WebRtcVoiceEngineTestFake, RecvUnsignaledAfterSignaled) { 2976 EXPECT_TRUE(SetupChannel()); 2977 uint8_t packet[sizeof(kPcmuFrame)]; 2978 memcpy(packet, kPcmuFrame, sizeof(kPcmuFrame)); 2979 2980 // Add a known stream, send packet and verify we got it. 2981 const uint32_t signaled_ssrc = 1; 2982 webrtc::SetBE32(&packet[8], signaled_ssrc); 2983 EXPECT_TRUE(AddRecvStream(signaled_ssrc)); 2984 DeliverPacket(packet); 2985 EXPECT_TRUE(GetRecvStream(signaled_ssrc).VerifyLastPacket(packet)); 2986 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 2987 2988 // Note that the first unknown SSRC cannot be 0, because we only support 2989 // creating receive streams for SSRC!=0. 2990 const uint32_t unsignaled_ssrc = 7011; 2991 webrtc::SetBE32(&packet[8], unsignaled_ssrc); 2992 DeliverPacket(packet); 2993 EXPECT_TRUE(GetRecvStream(unsignaled_ssrc).VerifyLastPacket(packet)); 2994 EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); 2995 2996 DeliverPacket(packet); 2997 EXPECT_EQ(2, GetRecvStream(unsignaled_ssrc).received_packets()); 2998 2999 webrtc::SetBE32(&packet[8], signaled_ssrc); 3000 DeliverPacket(packet); 3001 EXPECT_EQ(2, GetRecvStream(signaled_ssrc).received_packets()); 3002 EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); 3003 } 3004 3005 // Two tests to verify that adding a receive stream with the same SSRC as a 3006 // previously added unsignaled stream will only recreate underlying stream 3007 // objects if the stream parameters have changed. 3008 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamAfterUnsignaled_NoRecreate) { 3009 EXPECT_TRUE(SetupChannel()); 3010 3011 // Spawn unsignaled stream with SSRC=1. 3012 DeliverPacket(kPcmuFrame); 3013 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 3014 EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame)); 3015 3016 // Verify that the underlying stream object in Call is not recreated when a 3017 // stream with SSRC=1 is added. 3018 const auto& streams = call_.GetAudioReceiveStreams(); 3019 EXPECT_EQ(1u, streams.size()); 3020 int audio_receive_stream_id = streams.front()->id(); 3021 EXPECT_TRUE(AddRecvStream(1)); 3022 EXPECT_EQ(1u, streams.size()); 3023 EXPECT_EQ(audio_receive_stream_id, streams.front()->id()); 3024 } 3025 3026 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamAfterUnsignaled_Updates) { 3027 EXPECT_TRUE(SetupChannel()); 3028 3029 // Spawn unsignaled stream with SSRC=1. 3030 DeliverPacket(kPcmuFrame); 3031 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 3032 EXPECT_TRUE(GetRecvStream(1).VerifyLastPacket(kPcmuFrame)); 3033 3034 // Verify that the underlying stream object in Call gets updated when a 3035 // stream with SSRC=1 is added, and which has changed stream parameters. 3036 const auto& streams = call_.GetAudioReceiveStreams(); 3037 EXPECT_EQ(1u, streams.size()); 3038 // The sync_group id should be empty. 3039 EXPECT_TRUE(streams.front()->GetConfig().sync_group.empty()); 3040 3041 const std::string new_stream_id("stream_id"); 3042 int audio_receive_stream_id = streams.front()->id(); 3043 webrtc::StreamParams stream_params; 3044 stream_params.ssrcs.push_back(1); 3045 stream_params.set_stream_ids({new_stream_id}); 3046 3047 EXPECT_TRUE(receive_channel_->AddRecvStream(stream_params)); 3048 EXPECT_EQ(1u, streams.size()); 3049 // The audio receive stream should not have been recreated. 3050 EXPECT_EQ(audio_receive_stream_id, streams.front()->id()); 3051 3052 // The sync_group id should now match with the new stream params. 3053 EXPECT_EQ(new_stream_id, streams.front()->GetConfig().sync_group); 3054 } 3055 3056 // Test that AddRecvStream creates new stream. 3057 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStream) { 3058 EXPECT_TRUE(SetupRecvStream()); 3059 EXPECT_TRUE(AddRecvStream(1)); 3060 } 3061 3062 // Test that after adding a recv stream, we do not decode more codecs than 3063 // those previously passed into SetRecvCodecs. 3064 TEST_P(WebRtcVoiceEngineTestFake, AddRecvStreamUnsupportedCodec) { 3065 EXPECT_TRUE(SetupSendStream()); 3066 webrtc::AudioReceiverParameters parameters; 3067 parameters.codecs.push_back(kOpusCodec); 3068 parameters.codecs.push_back(kPcmuCodec); 3069 EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters)); 3070 EXPECT_TRUE(AddRecvStream(kSsrcX)); 3071 EXPECT_THAT(GetRecvStreamConfig(kSsrcX).decoder_map, 3072 (ContainerEq<std::map<int, webrtc::SdpAudioFormat>>( 3073 {{0, {"PCMU", 8000, 1}}, {111, {"OPUS", 48000, 2}}}))); 3074 } 3075 3076 // Test that we properly clean up any streams that were added, even if 3077 // not explicitly removed. 3078 TEST_P(WebRtcVoiceEngineTestFake, StreamCleanup) { 3079 EXPECT_TRUE(SetupSendStream()); 3080 SetSenderParameters(send_parameters_); 3081 EXPECT_TRUE(AddRecvStream(1)); 3082 EXPECT_TRUE(AddRecvStream(2)); 3083 3084 EXPECT_EQ(1u, call_.GetAudioSendStreams().size()); 3085 EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); 3086 send_channel_.reset(); 3087 receive_channel_.reset(); 3088 EXPECT_EQ(0u, call_.GetAudioSendStreams().size()); 3089 EXPECT_EQ(0u, call_.GetAudioReceiveStreams().size()); 3090 } 3091 3092 TEST_P(WebRtcVoiceEngineTestFake, TestAddRecvStreamSuccessWithZeroSsrc) { 3093 EXPECT_TRUE(SetupSendStream()); 3094 EXPECT_TRUE(AddRecvStream(0)); 3095 } 3096 3097 TEST_P(WebRtcVoiceEngineTestFake, TestAddRecvStreamFailWithSameSsrc) { 3098 EXPECT_TRUE(SetupChannel()); 3099 EXPECT_TRUE(AddRecvStream(1)); 3100 EXPECT_FALSE(AddRecvStream(1)); 3101 } 3102 3103 // Test the InsertDtmf on default send stream as caller. 3104 TEST_P(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCaller) { 3105 TestInsertDtmf(0, true, kTelephoneEventCodec1); 3106 } 3107 3108 // Test the InsertDtmf on default send stream as callee 3109 TEST_P(WebRtcVoiceEngineTestFake, InsertDtmfOnDefaultSendStreamAsCallee) { 3110 TestInsertDtmf(0, false, kTelephoneEventCodec2); 3111 } 3112 3113 // Test the InsertDtmf on specified send stream as caller. 3114 TEST_P(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCaller) { 3115 TestInsertDtmf(kSsrcX, true, kTelephoneEventCodec2); 3116 } 3117 3118 // Test the InsertDtmf on specified send stream as callee. 3119 TEST_P(WebRtcVoiceEngineTestFake, InsertDtmfOnSendStreamAsCallee) { 3120 TestInsertDtmf(kSsrcX, false, kTelephoneEventCodec1); 3121 } 3122 3123 // Test propagation of extmap allow mixed setting. 3124 TEST_P(WebRtcVoiceEngineTestFake, SetExtmapAllowMixedAsCaller) { 3125 TestExtmapAllowMixedCaller(/*extmap_allow_mixed=*/true); 3126 } 3127 TEST_P(WebRtcVoiceEngineTestFake, SetExtmapAllowMixedDisabledAsCaller) { 3128 TestExtmapAllowMixedCaller(/*extmap_allow_mixed=*/false); 3129 } 3130 TEST_P(WebRtcVoiceEngineTestFake, SetExtmapAllowMixedAsCallee) { 3131 TestExtmapAllowMixedCallee(/*extmap_allow_mixed=*/true); 3132 } 3133 TEST_P(WebRtcVoiceEngineTestFake, SetExtmapAllowMixedDisabledAsCallee) { 3134 TestExtmapAllowMixedCallee(/*extmap_allow_mixed=*/false); 3135 } 3136 3137 TEST_P(WebRtcVoiceEngineTestFake, SetAudioOptions) { 3138 EXPECT_TRUE(SetupSendStream()); 3139 EXPECT_TRUE(AddRecvStream(kSsrcY)); 3140 EXPECT_CALL(*adm_, BuiltInAECIsAvailable()) 3141 .Times(8) 3142 .WillRepeatedly(Return(false)); 3143 EXPECT_CALL(*adm_, BuiltInAGCIsAvailable()) 3144 .Times(4) 3145 .WillRepeatedly(Return(false)); 3146 EXPECT_CALL(*adm_, BuiltInNSIsAvailable()) 3147 .Times(2) 3148 .WillRepeatedly(Return(false)); 3149 3150 EXPECT_EQ(200u, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets); 3151 EXPECT_FALSE(GetRecvStreamConfig(kSsrcY).jitter_buffer_fast_accelerate); 3152 3153 // Nothing set in AudioOptions, so everything should be as default. 3154 send_parameters_.options = webrtc::AudioOptions(); 3155 SetSenderParameters(send_parameters_); 3156 if (!use_null_apm_) { 3157 VerifyEchoCancellationSettings(/*enabled=*/true); 3158 EXPECT_TRUE(IsHighPassFilterEnabled()); 3159 } 3160 EXPECT_EQ(200u, GetRecvStreamConfig(kSsrcY).jitter_buffer_max_packets); 3161 EXPECT_FALSE(GetRecvStreamConfig(kSsrcY).jitter_buffer_fast_accelerate); 3162 3163 // Turn echo cancellation off 3164 send_parameters_.options.echo_cancellation = false; 3165 SetSenderParameters(send_parameters_); 3166 if (!use_null_apm_) { 3167 VerifyEchoCancellationSettings(/*enabled=*/false); 3168 } 3169 3170 // Turn echo cancellation back on, with settings, and make sure 3171 // nothing else changed. 3172 send_parameters_.options.echo_cancellation = true; 3173 SetSenderParameters(send_parameters_); 3174 if (!use_null_apm_) { 3175 VerifyEchoCancellationSettings(/*enabled=*/true); 3176 } 3177 3178 // Turn off echo cancellation and delay agnostic aec. 3179 send_parameters_.options.echo_cancellation = false; 3180 SetSenderParameters(send_parameters_); 3181 if (!use_null_apm_) { 3182 VerifyEchoCancellationSettings(/*enabled=*/false); 3183 } 3184 3185 // Restore AEC to be on to work with the following tests. 3186 send_parameters_.options.echo_cancellation = true; 3187 SetSenderParameters(send_parameters_); 3188 3189 // Turn off AGC 3190 send_parameters_.options.auto_gain_control = false; 3191 SetSenderParameters(send_parameters_); 3192 if (!use_null_apm_) { 3193 VerifyEchoCancellationSettings(/*enabled=*/true); 3194 EXPECT_FALSE(apm_config_.gain_controller1.enabled); 3195 } 3196 3197 // Turn AGC back on 3198 send_parameters_.options.auto_gain_control = true; 3199 SetSenderParameters(send_parameters_); 3200 if (!use_null_apm_) { 3201 VerifyEchoCancellationSettings(/*enabled=*/true); 3202 EXPECT_TRUE(apm_config_.gain_controller1.enabled); 3203 } 3204 3205 // Turn off other options. 3206 send_parameters_.options.noise_suppression = false; 3207 send_parameters_.options.highpass_filter = false; 3208 send_parameters_.options.stereo_swapping = true; 3209 SetSenderParameters(send_parameters_); 3210 if (!use_null_apm_) { 3211 VerifyEchoCancellationSettings(/*enabled=*/true); 3212 EXPECT_FALSE(IsHighPassFilterEnabled()); 3213 EXPECT_TRUE(apm_config_.gain_controller1.enabled); 3214 EXPECT_FALSE(apm_config_.noise_suppression.enabled); 3215 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3216 } 3217 3218 // Set options again to ensure it has no impact. 3219 SetSenderParameters(send_parameters_); 3220 if (!use_null_apm_) { 3221 VerifyEchoCancellationSettings(/*enabled=*/true); 3222 EXPECT_TRUE(apm_config_.gain_controller1.enabled); 3223 EXPECT_FALSE(apm_config_.noise_suppression.enabled); 3224 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3225 } 3226 } 3227 3228 TEST_P(WebRtcVoiceEngineTestFake, InitRecordingOnSend) { 3229 EXPECT_CALL(*adm_, RecordingIsInitialized()).WillOnce(Return(false)); 3230 EXPECT_CALL(*adm_, Recording()).WillOnce(Return(false)); 3231 EXPECT_CALL(*adm_, InitRecording()).Times(1); 3232 3233 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel( 3234 engine_->CreateSendChannel( 3235 env_, &call_, webrtc::MediaConfig(), webrtc::AudioOptions(), 3236 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); 3237 3238 send_channel->SetSend(true); 3239 } 3240 3241 TEST_P(WebRtcVoiceEngineTestFake, SkipInitRecordingOnSend) { 3242 EXPECT_CALL(*adm_, RecordingIsInitialized()).Times(0); 3243 EXPECT_CALL(*adm_, Recording()).Times(0); 3244 EXPECT_CALL(*adm_, InitRecording()).Times(0); 3245 3246 webrtc::AudioOptions options; 3247 options.init_recording_on_send = false; 3248 3249 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel( 3250 engine_->CreateSendChannel(env_, &call_, webrtc::MediaConfig(), options, 3251 webrtc::CryptoOptions(), 3252 webrtc::AudioCodecPairId::Create())); 3253 3254 send_channel->SetSend(true); 3255 } 3256 3257 TEST_P(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { 3258 EXPECT_TRUE(SetupSendStream()); 3259 EXPECT_CALL(*adm_, BuiltInAECIsAvailable()) 3260 .Times(use_null_apm_ ? 4 : 8) 3261 .WillRepeatedly(Return(false)); 3262 EXPECT_CALL(*adm_, BuiltInAGCIsAvailable()) 3263 .Times(use_null_apm_ ? 7 : 8) 3264 .WillRepeatedly(Return(false)); 3265 EXPECT_CALL(*adm_, BuiltInNSIsAvailable()) 3266 .Times(use_null_apm_ ? 5 : 8) 3267 .WillRepeatedly(Return(false)); 3268 EXPECT_CALL(*adm_, RecordingIsInitialized()) 3269 .Times(2) 3270 .WillRepeatedly(Return(false)); 3271 3272 EXPECT_CALL(*adm_, Recording()).Times(2).WillRepeatedly(Return(false)); 3273 EXPECT_CALL(*adm_, InitRecording()).Times(2).WillRepeatedly(Return(0)); 3274 3275 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel1( 3276 engine_->CreateSendChannel( 3277 env_, &call_, webrtc::MediaConfig(), webrtc::AudioOptions(), 3278 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); 3279 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel2( 3280 engine_->CreateSendChannel( 3281 env_, &call_, webrtc::MediaConfig(), webrtc::AudioOptions(), 3282 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create())); 3283 3284 // Have to add a stream to make SetSend work. 3285 webrtc::StreamParams stream1; 3286 stream1.ssrcs.push_back(1); 3287 send_channel1->AddSendStream(stream1); 3288 webrtc::StreamParams stream2; 3289 stream2.ssrcs.push_back(2); 3290 send_channel2->AddSendStream(stream2); 3291 3292 // AEC and AGC and NS 3293 webrtc::AudioSenderParameter parameters_options_all = send_parameters_; 3294 parameters_options_all.options.echo_cancellation = true; 3295 parameters_options_all.options.auto_gain_control = true; 3296 parameters_options_all.options.noise_suppression = true; 3297 EXPECT_TRUE(send_channel1->SetSenderParameters(parameters_options_all)); 3298 if (!use_null_apm_) { 3299 VerifyEchoCancellationSettings(/*enabled=*/true); 3300 VerifyGainControlEnabledCorrectly(); 3301 EXPECT_TRUE(apm_config_.noise_suppression.enabled); 3302 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3303 EXPECT_EQ(parameters_options_all.options, 3304 SendImplFromPointer(send_channel1.get())->options()); 3305 EXPECT_TRUE(send_channel2->SetSenderParameters(parameters_options_all)); 3306 VerifyEchoCancellationSettings(/*enabled=*/true); 3307 VerifyGainControlEnabledCorrectly(); 3308 EXPECT_EQ(parameters_options_all.options, 3309 SendImplFromPointer(send_channel2.get())->options()); 3310 } 3311 3312 // unset NS 3313 webrtc::AudioSenderParameter parameters_options_no_ns = send_parameters_; 3314 parameters_options_no_ns.options.noise_suppression = false; 3315 EXPECT_TRUE(send_channel1->SetSenderParameters(parameters_options_no_ns)); 3316 webrtc::AudioOptions expected_options = parameters_options_all.options; 3317 if (!use_null_apm_) { 3318 VerifyEchoCancellationSettings(/*enabled=*/true); 3319 EXPECT_FALSE(apm_config_.noise_suppression.enabled); 3320 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3321 VerifyGainControlEnabledCorrectly(); 3322 expected_options.echo_cancellation = true; 3323 expected_options.auto_gain_control = true; 3324 expected_options.noise_suppression = false; 3325 EXPECT_EQ(expected_options, 3326 SendImplFromPointer(send_channel1.get())->options()); 3327 } 3328 3329 // unset AGC 3330 webrtc::AudioSenderParameter parameters_options_no_agc = send_parameters_; 3331 parameters_options_no_agc.options.auto_gain_control = false; 3332 EXPECT_TRUE(send_channel2->SetSenderParameters(parameters_options_no_agc)); 3333 if (!use_null_apm_) { 3334 VerifyEchoCancellationSettings(/*enabled=*/true); 3335 EXPECT_FALSE(apm_config_.gain_controller1.enabled); 3336 EXPECT_TRUE(apm_config_.noise_suppression.enabled); 3337 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3338 expected_options.echo_cancellation = true; 3339 expected_options.auto_gain_control = false; 3340 expected_options.noise_suppression = true; 3341 EXPECT_EQ(expected_options, 3342 SendImplFromPointer(send_channel2.get())->options()); 3343 } 3344 3345 EXPECT_TRUE(send_channel_->SetSenderParameters(parameters_options_all)); 3346 if (!use_null_apm_) { 3347 VerifyEchoCancellationSettings(/*enabled=*/true); 3348 VerifyGainControlEnabledCorrectly(); 3349 EXPECT_TRUE(apm_config_.noise_suppression.enabled); 3350 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3351 } 3352 3353 send_channel1->SetSend(true); 3354 if (!use_null_apm_) { 3355 VerifyEchoCancellationSettings(/*enabled=*/true); 3356 VerifyGainControlEnabledCorrectly(); 3357 EXPECT_FALSE(apm_config_.noise_suppression.enabled); 3358 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3359 } 3360 3361 send_channel2->SetSend(true); 3362 if (!use_null_apm_) { 3363 VerifyEchoCancellationSettings(/*enabled=*/true); 3364 EXPECT_FALSE(apm_config_.gain_controller1.enabled); 3365 EXPECT_TRUE(apm_config_.noise_suppression.enabled); 3366 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3367 } 3368 3369 // Make sure settings take effect while we are sending. 3370 webrtc::AudioSenderParameter parameters_options_no_agc_nor_ns = 3371 send_parameters_; 3372 parameters_options_no_agc_nor_ns.options.auto_gain_control = false; 3373 parameters_options_no_agc_nor_ns.options.noise_suppression = false; 3374 EXPECT_TRUE( 3375 send_channel2->SetSenderParameters(parameters_options_no_agc_nor_ns)); 3376 if (!use_null_apm_) { 3377 VerifyEchoCancellationSettings(/*enabled=*/true); 3378 EXPECT_FALSE(apm_config_.gain_controller1.enabled); 3379 EXPECT_FALSE(apm_config_.noise_suppression.enabled); 3380 EXPECT_EQ(apm_config_.noise_suppression.level, kDefaultNsLevel); 3381 expected_options.echo_cancellation = true; 3382 expected_options.auto_gain_control = false; 3383 expected_options.noise_suppression = false; 3384 EXPECT_EQ(expected_options, 3385 SendImplFromPointer(send_channel2.get())->options()); 3386 } 3387 } 3388 3389 // This test verifies DSCP settings are properly applied on voice media channel. 3390 TEST_P(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { 3391 EXPECT_TRUE(SetupSendStream()); 3392 webrtc::FakeNetworkInterface network_interface; 3393 webrtc::MediaConfig config; 3394 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> channel; 3395 webrtc::RtpParameters parameters; 3396 3397 channel = engine_->CreateSendChannel( 3398 env_, &call_, config, webrtc::AudioOptions(), webrtc::CryptoOptions(), 3399 webrtc::AudioCodecPairId::Create()); 3400 channel->SetInterface(&network_interface); 3401 // Default value when DSCP is disabled should be DSCP_DEFAULT. 3402 EXPECT_EQ(webrtc::DSCP_DEFAULT, network_interface.dscp()); 3403 channel->SetInterface(nullptr); 3404 3405 config.enable_dscp = true; 3406 channel = engine_->CreateSendChannel( 3407 env_, &call_, config, webrtc::AudioOptions(), webrtc::CryptoOptions(), 3408 webrtc::AudioCodecPairId::Create()); 3409 channel->SetInterface(&network_interface); 3410 EXPECT_EQ(webrtc::DSCP_DEFAULT, network_interface.dscp()); 3411 3412 // Create a send stream to configure 3413 EXPECT_TRUE( 3414 channel->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcZ))); 3415 parameters = channel->GetRtpSendParameters(kSsrcZ); 3416 ASSERT_FALSE(parameters.encodings.empty()); 3417 3418 // Various priorities map to various dscp values. 3419 parameters.encodings[0].network_priority = webrtc::Priority::kHigh; 3420 ASSERT_TRUE(channel->SetRtpSendParameters(kSsrcZ, parameters, nullptr).ok()); 3421 EXPECT_EQ(webrtc::DSCP_EF, network_interface.dscp()); 3422 parameters.encodings[0].network_priority = webrtc::Priority::kVeryLow; 3423 ASSERT_TRUE(channel->SetRtpSendParameters(kSsrcZ, parameters, nullptr).ok()); 3424 EXPECT_EQ(webrtc::DSCP_CS1, network_interface.dscp()); 3425 3426 // Packets should also self-identify their dscp in PacketOptions. 3427 const uint8_t kData[10] = {0}; 3428 EXPECT_TRUE(SendImplFromPointer(channel.get()) 3429 ->transport() 3430 ->SendRtcp(kData, /*packet_options=*/{})); 3431 EXPECT_EQ(webrtc::DSCP_CS1, network_interface.options().dscp); 3432 channel->SetInterface(nullptr); 3433 3434 // Verify that setting the option to false resets the 3435 // DiffServCodePoint. 3436 config.enable_dscp = false; 3437 channel = engine_->CreateSendChannel( 3438 env_, &call_, config, webrtc::AudioOptions(), webrtc::CryptoOptions(), 3439 webrtc::AudioCodecPairId::Create()); 3440 channel->SetInterface(&network_interface); 3441 // Default value when DSCP is disabled should be DSCP_DEFAULT. 3442 EXPECT_EQ(webrtc::DSCP_DEFAULT, network_interface.dscp()); 3443 3444 channel->SetInterface(nullptr); 3445 } 3446 3447 TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolume) { 3448 EXPECT_TRUE(SetupChannel()); 3449 EXPECT_FALSE(receive_channel_->SetOutputVolume(kSsrcY, 0.5)); 3450 webrtc::StreamParams stream; 3451 stream.ssrcs.push_back(kSsrcY); 3452 EXPECT_TRUE(receive_channel_->AddRecvStream(stream)); 3453 EXPECT_DOUBLE_EQ(1, GetRecvStream(kSsrcY).gain()); 3454 EXPECT_TRUE(receive_channel_->SetOutputVolume(kSsrcY, 3)); 3455 EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrcY).gain()); 3456 } 3457 3458 TEST_P(WebRtcVoiceEngineTestFake, SetOutputVolumeUnsignaledRecvStream) { 3459 EXPECT_TRUE(SetupChannel()); 3460 3461 // Spawn an unsignaled stream by sending a packet - gain should be 1. 3462 DeliverPacket(kPcmuFrame); 3463 EXPECT_DOUBLE_EQ(1, GetRecvStream(kSsrc1).gain()); 3464 3465 // Should remember the volume "2" which will be set on new unsignaled streams, 3466 // and also set the gain to 2 on existing unsignaled streams. 3467 EXPECT_TRUE(receive_channel_->SetDefaultOutputVolume(2)); 3468 EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrc1).gain()); 3469 3470 // Spawn an unsignaled stream by sending a packet - gain should be 2. 3471 uint8_t pcmuFrame2[sizeof(kPcmuFrame)]; 3472 memcpy(pcmuFrame2, kPcmuFrame, sizeof(kPcmuFrame)); 3473 webrtc::SetBE32(&pcmuFrame2[8], kSsrcX); 3474 DeliverPacket(pcmuFrame2); 3475 EXPECT_DOUBLE_EQ(2, GetRecvStream(kSsrcX).gain()); 3476 3477 // Setting gain for all unsignaled streams. 3478 EXPECT_TRUE(receive_channel_->SetDefaultOutputVolume(3)); 3479 if (kMaxUnsignaledRecvStreams > 1) { 3480 EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain()); 3481 } 3482 EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrcX).gain()); 3483 3484 // Setting gain on an individual stream affects only that. 3485 EXPECT_TRUE(receive_channel_->SetOutputVolume(kSsrcX, 4)); 3486 if (kMaxUnsignaledRecvStreams > 1) { 3487 EXPECT_DOUBLE_EQ(3, GetRecvStream(kSsrc1).gain()); 3488 } 3489 EXPECT_DOUBLE_EQ(4, GetRecvStream(kSsrcX).gain()); 3490 } 3491 3492 TEST_P(WebRtcVoiceEngineTestFake, BaseMinimumPlayoutDelayMs) { 3493 EXPECT_TRUE(SetupChannel()); 3494 EXPECT_FALSE(receive_channel_->SetBaseMinimumPlayoutDelayMs(kSsrcY, 200)); 3495 EXPECT_FALSE( 3496 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcY).has_value()); 3497 3498 webrtc::StreamParams stream; 3499 stream.ssrcs.push_back(kSsrcY); 3500 EXPECT_TRUE(receive_channel_->AddRecvStream(stream)); 3501 EXPECT_EQ(0, GetRecvStream(kSsrcY).base_mininum_playout_delay_ms()); 3502 EXPECT_TRUE(receive_channel_->SetBaseMinimumPlayoutDelayMs(kSsrcY, 300)); 3503 EXPECT_EQ(300, GetRecvStream(kSsrcY).base_mininum_playout_delay_ms()); 3504 } 3505 3506 TEST_P(WebRtcVoiceEngineTestFake, 3507 BaseMinimumPlayoutDelayMsUnsignaledRecvStream) { 3508 // Here base minimum delay is abbreviated to delay in comments for shortness. 3509 EXPECT_TRUE(SetupChannel()); 3510 3511 // Spawn an unsignaled stream by sending a packet - delay should be 0. 3512 DeliverPacket(kPcmuFrame); 3513 EXPECT_EQ( 3514 0, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc1).value_or(-1)); 3515 // Check that it doesn't provide default values for unknown ssrc. 3516 EXPECT_FALSE( 3517 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcY).has_value()); 3518 3519 // Check that default value for unsignaled streams is 0. 3520 EXPECT_EQ( 3521 0, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc0).value_or(-1)); 3522 3523 // Should remember the delay 100 which will be set on new unsignaled streams, 3524 // and also set the delay to 100 on existing unsignaled streams. 3525 EXPECT_TRUE(receive_channel_->SetBaseMinimumPlayoutDelayMs(kSsrc0, 100)); 3526 EXPECT_EQ( 3527 100, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc0).value_or(-1)); 3528 // Check that it doesn't provide default values for unknown ssrc. 3529 EXPECT_FALSE( 3530 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcY).has_value()); 3531 3532 // Spawn an unsignaled stream by sending a packet - delay should be 100. 3533 uint8_t pcmuFrame2[sizeof(kPcmuFrame)]; 3534 memcpy(pcmuFrame2, kPcmuFrame, sizeof(kPcmuFrame)); 3535 webrtc::SetBE32(&pcmuFrame2[8], kSsrcX); 3536 DeliverPacket(pcmuFrame2); 3537 EXPECT_EQ( 3538 100, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcX).value_or(-1)); 3539 3540 // Setting delay with SSRC=0 should affect all unsignaled streams. 3541 EXPECT_TRUE(receive_channel_->SetBaseMinimumPlayoutDelayMs(kSsrc0, 300)); 3542 if (kMaxUnsignaledRecvStreams > 1) { 3543 EXPECT_EQ( 3544 300, 3545 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc1).value_or(-1)); 3546 } 3547 EXPECT_EQ( 3548 300, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcX).value_or(-1)); 3549 3550 // Setting delay on an individual stream affects only that. 3551 EXPECT_TRUE(receive_channel_->SetBaseMinimumPlayoutDelayMs(kSsrcX, 400)); 3552 if (kMaxUnsignaledRecvStreams > 1) { 3553 EXPECT_EQ( 3554 300, 3555 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc1).value_or(-1)); 3556 } 3557 EXPECT_EQ( 3558 400, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcX).value_or(-1)); 3559 EXPECT_EQ( 3560 300, receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrc0).value_or(-1)); 3561 // Check that it doesn't provide default values for unknown ssrc. 3562 EXPECT_FALSE( 3563 receive_channel_->GetBaseMinimumPlayoutDelayMs(kSsrcY).has_value()); 3564 } 3565 3566 TEST_P(WebRtcVoiceEngineTestFake, SetsSyncGroupFromStreamId) { 3567 const uint32_t kAudioSsrc = 123; 3568 const std::string kStreamId = "AvSyncLabel"; 3569 3570 EXPECT_TRUE(SetupSendStream()); 3571 webrtc::StreamParams sp = webrtc::StreamParams::CreateLegacy(kAudioSsrc); 3572 sp.set_stream_ids({kStreamId}); 3573 // Creating two channels to make sure that sync label is set properly for both 3574 // the default voice channel and following ones. 3575 EXPECT_TRUE(receive_channel_->AddRecvStream(sp)); 3576 sp.ssrcs[0] += 1; 3577 EXPECT_TRUE(receive_channel_->AddRecvStream(sp)); 3578 3579 ASSERT_EQ(2u, call_.GetAudioReceiveStreams().size()); 3580 EXPECT_EQ(kStreamId, 3581 call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group) 3582 << "SyncGroup should be set based on stream id"; 3583 EXPECT_EQ(kStreamId, 3584 call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group) 3585 << "SyncGroup should be set based on stream id"; 3586 } 3587 3588 // TODO(solenberg): Remove, once recv streams are configured through Call. 3589 // (This is then covered by TestSetRecvRtpHeaderExtensions.) 3590 TEST_P(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { 3591 // Test that setting the header extensions results in the expected state 3592 // changes on an associated Call. 3593 std::vector<uint32_t> ssrcs; 3594 ssrcs.push_back(223); 3595 ssrcs.push_back(224); 3596 3597 EXPECT_TRUE(SetupSendStream()); 3598 SetSenderParameters(send_parameters_); 3599 for (uint32_t ssrc : ssrcs) { 3600 EXPECT_TRUE(receive_channel_->AddRecvStream( 3601 webrtc::StreamParams::CreateLegacy(ssrc))); 3602 } 3603 3604 EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); 3605 for (uint32_t ssrc : ssrcs) { 3606 EXPECT_THAT( 3607 receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, 3608 IsEmpty()); 3609 } 3610 3611 // Set up receive extensions. 3612 const std::vector<webrtc::RtpExtension> header_extensions = 3613 webrtc::GetDefaultEnabledRtpHeaderExtensions(*engine_, 3614 /* field_trials= */ nullptr); 3615 webrtc::AudioReceiverParameters recv_parameters; 3616 recv_parameters.extensions = header_extensions; 3617 receive_channel_->SetReceiverParameters(recv_parameters); 3618 EXPECT_EQ(2u, call_.GetAudioReceiveStreams().size()); 3619 for (uint32_t ssrc : ssrcs) { 3620 EXPECT_THAT( 3621 receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, 3622 testing::UnorderedElementsAreArray(header_extensions)); 3623 } 3624 3625 // Disable receive extensions. 3626 receive_channel_->SetReceiverParameters(webrtc::AudioReceiverParameters()); 3627 for (uint32_t ssrc : ssrcs) { 3628 EXPECT_THAT( 3629 receive_channel_->GetRtpReceiverParameters(ssrc).header_extensions, 3630 IsEmpty()); 3631 } 3632 } 3633 3634 TEST_P(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) { 3635 // Test that packets are forwarded to the Call when configured accordingly. 3636 const uint32_t kAudioSsrc = 1; 3637 webrtc::CopyOnWriteBuffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame)); 3638 static const uint8_t kRtcp[] = { 3639 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 3640 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3641 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 3642 webrtc::CopyOnWriteBuffer kRtcpPacket(kRtcp, sizeof(kRtcp)); 3643 3644 EXPECT_TRUE(SetupSendStream()); 3645 webrtc::VoiceMediaReceiveChannelInterface* media_channel = ReceiveImpl(); 3646 SetSenderParameters(send_parameters_); 3647 EXPECT_TRUE(media_channel->AddRecvStream( 3648 webrtc::StreamParams::CreateLegacy(kAudioSsrc))); 3649 3650 EXPECT_EQ(1u, call_.GetAudioReceiveStreams().size()); 3651 const webrtc::FakeAudioReceiveStream* s = 3652 call_.GetAudioReceiveStream(kAudioSsrc); 3653 EXPECT_EQ(0, s->received_packets()); 3654 webrtc::RtpPacketReceived parsed_packet; 3655 RTC_CHECK(parsed_packet.Parse(kPcmuPacket)); 3656 receive_channel_->OnPacketReceived(parsed_packet); 3657 webrtc::Thread::Current()->ProcessMessages(0); 3658 3659 EXPECT_EQ(1, s->received_packets()); 3660 } 3661 3662 // All receive channels should be associated with the first send channel, 3663 // since they do not send RTCP SR. 3664 TEST_P(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel_SendCreatedFirst) { 3665 EXPECT_TRUE(SetupSendStream()); 3666 EXPECT_TRUE(AddRecvStream(kSsrcY)); 3667 EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).rtp.local_ssrc); 3668 EXPECT_TRUE( 3669 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcZ))); 3670 EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcY).rtp.local_ssrc); 3671 EXPECT_TRUE(AddRecvStream(kSsrcW)); 3672 EXPECT_EQ(kSsrcX, GetRecvStreamConfig(kSsrcW).rtp.local_ssrc); 3673 } 3674 3675 TEST_P(WebRtcVoiceEngineTestFake, AssociateFirstSendChannel_RecvCreatedFirst) { 3676 EXPECT_TRUE(SetupRecvStream()); 3677 EXPECT_EQ(0xFA17FA17u, GetRecvStreamConfig(kSsrcX).rtp.local_ssrc); 3678 EXPECT_TRUE( 3679 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcY))); 3680 EXPECT_EQ(kSsrcY, GetRecvStreamConfig(kSsrcX).rtp.local_ssrc); 3681 EXPECT_TRUE(AddRecvStream(kSsrcZ)); 3682 EXPECT_EQ(kSsrcY, GetRecvStreamConfig(kSsrcZ).rtp.local_ssrc); 3683 EXPECT_TRUE( 3684 send_channel_->AddSendStream(webrtc::StreamParams::CreateLegacy(kSsrcW))); 3685 3686 EXPECT_EQ(kSsrcY, GetRecvStreamConfig(kSsrcX).rtp.local_ssrc); 3687 EXPECT_EQ(kSsrcY, GetRecvStreamConfig(kSsrcZ).rtp.local_ssrc); 3688 } 3689 3690 TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSink) { 3691 EXPECT_TRUE(SetupChannel()); 3692 std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink()); 3693 std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink()); 3694 3695 // Setting the sink before a recv stream exists should do nothing. 3696 receive_channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_1)); 3697 EXPECT_TRUE(AddRecvStream(kSsrcX)); 3698 EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); 3699 3700 // Now try actually setting the sink. 3701 receive_channel_->SetRawAudioSink(kSsrcX, std::move(fake_sink_2)); 3702 EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); 3703 3704 // Now try resetting it. 3705 receive_channel_->SetRawAudioSink(kSsrcX, nullptr); 3706 EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); 3707 } 3708 3709 TEST_P(WebRtcVoiceEngineTestFake, SetRawAudioSinkUnsignaledRecvStream) { 3710 EXPECT_TRUE(SetupChannel()); 3711 std::unique_ptr<FakeAudioSink> fake_sink_1(new FakeAudioSink()); 3712 std::unique_ptr<FakeAudioSink> fake_sink_2(new FakeAudioSink()); 3713 std::unique_ptr<FakeAudioSink> fake_sink_3(new FakeAudioSink()); 3714 std::unique_ptr<FakeAudioSink> fake_sink_4(new FakeAudioSink()); 3715 3716 // Should be able to set a default sink even when no stream exists. 3717 receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_1)); 3718 3719 // Spawn an unsignaled stream by sending a packet - it should be assigned the 3720 // default sink. 3721 DeliverPacket(kPcmuFrame); 3722 EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); 3723 3724 // Try resetting the default sink. 3725 receive_channel_->SetDefaultRawAudioSink(nullptr); 3726 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); 3727 3728 // Try setting the default sink while the default stream exists. 3729 receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_2)); 3730 EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); 3731 3732 // If we remove and add a default stream, it should get the same sink. 3733 EXPECT_TRUE(receive_channel_->RemoveRecvStream(kSsrc1)); 3734 DeliverPacket(kPcmuFrame); 3735 EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); 3736 3737 // Spawn another unsignaled stream - it should be assigned the default sink 3738 // and the previous unsignaled stream should lose it. 3739 uint8_t pcmuFrame2[sizeof(kPcmuFrame)]; 3740 memcpy(pcmuFrame2, kPcmuFrame, sizeof(kPcmuFrame)); 3741 webrtc::SetBE32(&pcmuFrame2[8], kSsrcX); 3742 DeliverPacket(pcmuFrame2); 3743 if (kMaxUnsignaledRecvStreams > 1) { 3744 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); 3745 } 3746 EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); 3747 3748 // Reset the default sink - the second unsignaled stream should lose it. 3749 receive_channel_->SetDefaultRawAudioSink(nullptr); 3750 if (kMaxUnsignaledRecvStreams > 1) { 3751 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); 3752 } 3753 EXPECT_EQ(nullptr, GetRecvStream(kSsrcX).sink()); 3754 3755 // Try setting the default sink while two streams exists. 3756 receive_channel_->SetDefaultRawAudioSink(std::move(fake_sink_3)); 3757 if (kMaxUnsignaledRecvStreams > 1) { 3758 EXPECT_EQ(nullptr, GetRecvStream(kSsrc1).sink()); 3759 } 3760 EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); 3761 3762 // Try setting the sink for the first unsignaled stream using its known SSRC. 3763 receive_channel_->SetRawAudioSink(kSsrc1, std::move(fake_sink_4)); 3764 if (kMaxUnsignaledRecvStreams > 1) { 3765 EXPECT_NE(nullptr, GetRecvStream(kSsrc1).sink()); 3766 } 3767 EXPECT_NE(nullptr, GetRecvStream(kSsrcX).sink()); 3768 if (kMaxUnsignaledRecvStreams > 1) { 3769 EXPECT_NE(GetRecvStream(kSsrc1).sink(), GetRecvStream(kSsrcX).sink()); 3770 } 3771 } 3772 3773 // Test that, just like the video channel, the voice channel communicates the 3774 // network state to the call. 3775 TEST_P(WebRtcVoiceEngineTestFake, OnReadyToSendSignalsNetworkState) { 3776 EXPECT_TRUE(SetupChannel()); 3777 3778 EXPECT_EQ(webrtc::kNetworkUp, 3779 call_.GetNetworkState(webrtc::MediaType::AUDIO)); 3780 EXPECT_EQ(webrtc::kNetworkUp, 3781 call_.GetNetworkState(webrtc::MediaType::VIDEO)); 3782 3783 send_channel_->OnReadyToSend(false); 3784 EXPECT_EQ(webrtc::kNetworkDown, 3785 call_.GetNetworkState(webrtc::MediaType::AUDIO)); 3786 EXPECT_EQ(webrtc::kNetworkUp, 3787 call_.GetNetworkState(webrtc::MediaType::VIDEO)); 3788 3789 send_channel_->OnReadyToSend(true); 3790 EXPECT_EQ(webrtc::kNetworkUp, 3791 call_.GetNetworkState(webrtc::MediaType::AUDIO)); 3792 EXPECT_EQ(webrtc::kNetworkUp, 3793 call_.GetNetworkState(webrtc::MediaType::VIDEO)); 3794 } 3795 3796 // Test that playout is still started after changing parameters 3797 TEST_P(WebRtcVoiceEngineTestFake, PreservePlayoutWhenRecreateRecvStream) { 3798 SetupRecvStream(); 3799 receive_channel_->SetPlayout(true); 3800 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); 3801 3802 // Changing RTP header extensions will recreate the 3803 // AudioReceiveStreamInterface. 3804 webrtc::AudioReceiverParameters parameters; 3805 parameters.extensions.push_back( 3806 webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri, 12)); 3807 receive_channel_->SetReceiverParameters(parameters); 3808 3809 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); 3810 } 3811 3812 // Tests when GetSources is called with non-existing ssrc, it will return an 3813 // empty list of RtpSource without crashing. 3814 TEST_P(WebRtcVoiceEngineTestFake, GetSourcesWithNonExistingSsrc) { 3815 // Setup an recv stream with `kSsrcX`. 3816 SetupRecvStream(); 3817 webrtc::WebRtcVoiceReceiveChannel* media_channel = ReceiveImpl(); 3818 // Call GetSources with `kSsrcY` which doesn't exist. 3819 std::vector<webrtc::RtpSource> sources = media_channel->GetSources(kSsrcY); 3820 EXPECT_EQ(0u, sources.size()); 3821 } 3822 3823 // Tests that the library initializes and shuts down properly. 3824 TEST(WebRtcVoiceEngineTest, StartupShutdown) { 3825 webrtc::AutoThread main_thread; 3826 for (bool use_null_apm : {false, true}) { 3827 // If the VoiceEngine wants to gather available codecs early, that's fine 3828 // but we never want it to create a decoder at this stage. 3829 Environment env = CreateEnvironment(); 3830 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 3831 webrtc::test::MockAudioDeviceModule::CreateNice(); 3832 scoped_refptr<AudioProcessing> apm = 3833 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 3834 webrtc::WebRtcVoiceEngine engine( 3835 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 3836 webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm, 3837 nullptr); 3838 engine.Init(); 3839 std::unique_ptr<Call> call = Call::Create(CallConfig(env)); 3840 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel = 3841 engine.CreateSendChannel( 3842 env, call.get(), webrtc::MediaConfig(), webrtc::AudioOptions(), 3843 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 3844 EXPECT_TRUE(send_channel); 3845 std::unique_ptr<webrtc::VoiceMediaReceiveChannelInterface> receive_channel = 3846 engine.CreateReceiveChannel( 3847 env, call.get(), webrtc::MediaConfig(), webrtc::AudioOptions(), 3848 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 3849 EXPECT_TRUE(receive_channel); 3850 } 3851 } 3852 3853 // Tests that reference counting on the external ADM is correct. 3854 TEST(WebRtcVoiceEngineTest, StartupShutdownWithExternalADM) { 3855 webrtc::AutoThread main_thread; 3856 for (bool use_null_apm : {false, true}) { 3857 Environment env = CreateEnvironment(); 3858 auto adm = webrtc::make_ref_counted< 3859 ::testing::NiceMock<webrtc::test::MockAudioDeviceModule>>(); 3860 { 3861 scoped_refptr<AudioProcessing> apm = 3862 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 3863 webrtc::WebRtcVoiceEngine engine( 3864 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 3865 webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm, 3866 nullptr); 3867 engine.Init(); 3868 std::unique_ptr<Call> call = Call::Create(CallConfig(env)); 3869 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> send_channel = 3870 engine.CreateSendChannel( 3871 env, call.get(), webrtc::MediaConfig(), webrtc::AudioOptions(), 3872 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 3873 EXPECT_TRUE(send_channel); 3874 std::unique_ptr<webrtc::VoiceMediaReceiveChannelInterface> 3875 receive_channel = engine.CreateReceiveChannel( 3876 env, call.get(), webrtc::MediaConfig(), webrtc::AudioOptions(), 3877 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 3878 EXPECT_TRUE(receive_channel); 3879 } 3880 // The engine/channel should have dropped their references. 3881 EXPECT_EQ(adm.release()->Release(), 3882 webrtc::RefCountReleaseStatus::kDroppedLastRef); 3883 } 3884 } 3885 3886 // Verify the payload id of common audio codecs, including CN and G722. 3887 TEST(WebRtcVoiceEngineTest, HasCorrectPayloadTypeMapping) { 3888 Environment env = CreateEnvironment(); 3889 for (bool use_null_apm : {false, true}) { 3890 // TODO(ossu): Why are the payload types of codecs with non-static payload 3891 // type assignments checked here? It shouldn't really matter. 3892 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 3893 webrtc::test::MockAudioDeviceModule::CreateNice(); 3894 scoped_refptr<AudioProcessing> apm = 3895 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 3896 webrtc::WebRtcVoiceEngine engine( 3897 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 3898 webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm, 3899 nullptr); 3900 engine.Init(); 3901 for (const webrtc::Codec& codec : engine.LegacySendCodecs()) { 3902 auto is_codec = [&codec](const char* name, int clockrate = 0) { 3903 return absl::EqualsIgnoreCase(codec.name, name) && 3904 (clockrate == 0 || codec.clockrate == clockrate); 3905 }; 3906 if (is_codec("CN", 16000)) { 3907 EXPECT_EQ(105, codec.id); 3908 } else if (is_codec("CN", 32000)) { 3909 EXPECT_EQ(106, codec.id); 3910 } else if (is_codec("G722", 8000)) { 3911 EXPECT_EQ(9, codec.id); 3912 } else if (is_codec("telephone-event", 8000)) { 3913 EXPECT_EQ(126, codec.id); 3914 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. 3915 // Remove these checks once both send and receive side assigns payload 3916 // types dynamically. 3917 } else if (is_codec("telephone-event", 16000)) { 3918 EXPECT_EQ(113, codec.id); 3919 } else if (is_codec("telephone-event", 32000)) { 3920 EXPECT_EQ(112, codec.id); 3921 } else if (is_codec("telephone-event", 48000)) { 3922 EXPECT_EQ(110, codec.id); 3923 } else if (is_codec("opus")) { 3924 EXPECT_EQ(111, codec.id); 3925 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); 3926 EXPECT_EQ("10", codec.params.find("minptime")->second); 3927 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); 3928 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); 3929 } 3930 } 3931 } 3932 } 3933 3934 // Tests that VoE supports at least 32 channels 3935 TEST(WebRtcVoiceEngineTest, Has32Channels) { 3936 webrtc::AutoThread main_thread; 3937 for (bool use_null_apm : {false, true}) { 3938 Environment env = CreateEnvironment(); 3939 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 3940 webrtc::test::MockAudioDeviceModule::CreateNice(); 3941 scoped_refptr<AudioProcessing> apm = 3942 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 3943 webrtc::WebRtcVoiceEngine engine( 3944 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 3945 webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm, 3946 nullptr); 3947 engine.Init(); 3948 std::unique_ptr<Call> call = Call::Create(CallConfig(env)); 3949 3950 std::vector<std::unique_ptr<webrtc::VoiceMediaSendChannelInterface>> 3951 channels; 3952 while (channels.size() < 32) { 3953 std::unique_ptr<webrtc::VoiceMediaSendChannelInterface> channel = 3954 engine.CreateSendChannel( 3955 env, call.get(), webrtc::MediaConfig(), webrtc::AudioOptions(), 3956 webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create()); 3957 if (!channel) 3958 break; 3959 channels.emplace_back(std::move(channel)); 3960 } 3961 3962 EXPECT_EQ(channels.size(), 32u); 3963 } 3964 } 3965 3966 // Test that we set our preferred codecs properly. 3967 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { 3968 webrtc::AutoThread main_thread; 3969 for (bool use_null_apm : {false, true}) { 3970 Environment env = CreateEnvironment(); 3971 // TODO(ossu): I'm not sure of the intent of this test. It's either: 3972 // - Check that our builtin codecs are usable by Channel. 3973 // - The codecs provided by the engine is usable by Channel. 3974 // It does not check that the codecs in the RecvParameters are actually 3975 // what we sent in - though it's probably reasonable to expect so, if 3976 // SetReceiverParameters returns true. 3977 // I think it will become clear once audio decoder injection is completed. 3978 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 3979 webrtc::test::MockAudioDeviceModule::CreateNice(); 3980 scoped_refptr<AudioProcessing> apm = 3981 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 3982 webrtc::WebRtcVoiceEngine engine( 3983 env, adm, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(), 3984 webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, apm, nullptr); 3985 engine.Init(); 3986 std::unique_ptr<Call> call = Call::Create(CallConfig(env)); 3987 webrtc::WebRtcVoiceReceiveChannel channel( 3988 env, &engine, webrtc::MediaConfig(), webrtc::AudioOptions(), 3989 webrtc::CryptoOptions(), call.get(), 3990 webrtc::AudioCodecPairId::Create()); 3991 webrtc::AudioReceiverParameters parameters; 3992 parameters.codecs = ReceiveCodecsWithId(engine); 3993 EXPECT_TRUE(channel.SetReceiverParameters(parameters)); 3994 } 3995 } 3996 3997 TEST(WebRtcVoiceEngineTest, SetRtpSendParametersMaxBitrate) { 3998 webrtc::AutoThread main_thread; 3999 Environment env = CreateEnvironment(); 4000 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 4001 webrtc::test::MockAudioDeviceModule::CreateNice(); 4002 FakeAudioSource source; 4003 webrtc::WebRtcVoiceEngine engine( 4004 env, adm, webrtc::CreateBuiltinAudioEncoderFactory(), 4005 webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, nullptr, nullptr); 4006 engine.Init(); 4007 CallConfig call_config(env); 4008 { 4009 webrtc::AudioState::Config config; 4010 config.audio_mixer = webrtc::AudioMixerImpl::Create(); 4011 config.audio_device_module = 4012 webrtc::test::MockAudioDeviceModule::CreateNice(); 4013 call_config.audio_state = webrtc::AudioState::Create(config); 4014 } 4015 std::unique_ptr<Call> call = Call::Create(std::move(call_config)); 4016 webrtc::WebRtcVoiceSendChannel channel( 4017 env, &engine, webrtc::MediaConfig(), webrtc::AudioOptions(), 4018 webrtc::CryptoOptions(), call.get(), webrtc::AudioCodecPairId::Create()); 4019 { 4020 webrtc::AudioSenderParameter params; 4021 params.codecs.push_back(webrtc::CreateAudioCodec(1, "opus", 48000, 2)); 4022 params.extensions.push_back(webrtc::RtpExtension( 4023 webrtc::RtpExtension::kTransportSequenceNumberUri, 1)); 4024 EXPECT_TRUE(channel.SetSenderParameters(params)); 4025 } 4026 constexpr int kSsrc = 1234; 4027 { 4028 webrtc::StreamParams params; 4029 params.add_ssrc(kSsrc); 4030 channel.AddSendStream(params); 4031 } 4032 channel.SetAudioSend(kSsrc, true, nullptr, &source); 4033 channel.SetSend(true); 4034 webrtc::RtpParameters params = channel.GetRtpSendParameters(kSsrc); 4035 for (int max_bitrate : {-10, -1, 0, 10000}) { 4036 params.encodings[0].max_bitrate_bps = max_bitrate; 4037 channel.SetRtpSendParameters( 4038 kSsrc, params, [](webrtc::RTCError error) { EXPECT_TRUE(error.ok()); }); 4039 } 4040 } 4041 4042 TEST(WebRtcVoiceEngineTest, CollectRecvCodecs) { 4043 Environment env = CreateEnvironment(); 4044 for (bool use_null_apm : {false, true}) { 4045 std::vector<webrtc::AudioCodecSpec> specs; 4046 webrtc::AudioCodecSpec spec1 = { 4047 .format = {"codec1", 48000, 2, {{"param1", "value1"}}}, 4048 .info = {48000, 2, 16000, 10000, 20000}, 4049 }; 4050 spec1.info.allow_comfort_noise = false; 4051 spec1.info.supports_network_adaption = true; 4052 specs.push_back(spec1); 4053 webrtc::AudioCodecSpec spec2 = { 4054 .format = {"codec2", 48000, 2, {{"param1", "value1"}}}, 4055 .info = {48000, 2, 16000, 10000, 20000}}; 4056 // We do not support 48khz CN. 4057 spec2.info.allow_comfort_noise = true; 4058 specs.push_back(spec2); 4059 specs.push_back({.format = {"codec3", 8000, 1}, .info = {8000, 1, 64000}}); 4060 specs.push_back({.format = {"codec4", 8000, 2}, .info = {8000, 1, 64000}}); 4061 4062 webrtc::scoped_refptr<webrtc::MockAudioEncoderFactory> 4063 unused_encoder_factory = 4064 webrtc::MockAudioEncoderFactory::CreateUnusedFactory(); 4065 webrtc::scoped_refptr<webrtc::MockAudioDecoderFactory> 4066 mock_decoder_factory = 4067 webrtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); 4068 EXPECT_CALL(*mock_decoder_factory.get(), GetSupportedDecoders()) 4069 .WillOnce(Return(specs)); 4070 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 4071 webrtc::test::MockAudioDeviceModule::CreateNice(); 4072 4073 scoped_refptr<AudioProcessing> apm = 4074 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 4075 webrtc::WebRtcVoiceEngine engine(env, adm, unused_encoder_factory, 4076 mock_decoder_factory, nullptr, apm, 4077 nullptr); 4078 engine.Init(); 4079 auto codecs = engine.LegacyRecvCodecs(); 4080 EXPECT_EQ(7u, codecs.size()); 4081 4082 // Rather than just ASSERTing that there are enough codecs, ensure that we 4083 // can check the actual values safely, to provide better test results. 4084 auto get_codec = [&codecs](size_t index) -> const webrtc::Codec& { 4085 static const webrtc::Codec missing_codec = webrtc::CreateAudioCodec( 4086 0, "<missing>", webrtc::kDefaultAudioClockRateHz, 0); 4087 if (codecs.size() > index) 4088 return codecs[index]; 4089 return missing_codec; 4090 }; 4091 4092 // Ensure the general codecs are generated first and in order. 4093 for (size_t i = 0; i != specs.size(); ++i) { 4094 EXPECT_EQ(specs[i].format.name, get_codec(i).name); 4095 EXPECT_EQ(specs[i].format.clockrate_hz, get_codec(i).clockrate); 4096 EXPECT_EQ(specs[i].format.num_channels, get_codec(i).channels); 4097 EXPECT_EQ(specs[i].format.parameters, get_codec(i).params); 4098 } 4099 4100 // Find the index of a codec, or -1 if not found, so that we can easily 4101 // check supplementary codecs are ordered after the general codecs. 4102 auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int { 4103 for (size_t i = 0; i != codecs.size(); ++i) { 4104 const webrtc::Codec& codec = codecs[i]; 4105 if (absl::EqualsIgnoreCase(codec.name, format.name) && 4106 codec.clockrate == format.clockrate_hz && 4107 codec.channels == format.num_channels) { 4108 return webrtc::checked_cast<int>(i); 4109 } 4110 } 4111 return -1; 4112 }; 4113 4114 // Ensure all supplementary codecs are generated last. Their internal 4115 // ordering is not important. Without this cast, the comparison turned 4116 // unsigned and, thus, failed for -1. 4117 const int num_specs = static_cast<int>(specs.size()); 4118 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); 4119 EXPECT_EQ(find_codec({"cn", 16000, 1}), -1); 4120 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); 4121 EXPECT_EQ(find_codec({"cn", 48000, 1}), -1); 4122 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); 4123 EXPECT_EQ(find_codec({"telephone-event", 16000, 1}), -1); 4124 EXPECT_EQ(find_codec({"telephone-event", 32000, 1}), -1); 4125 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); 4126 } 4127 } 4128 4129 TEST(WebRtcVoiceEngineTest, CollectRecvCodecsWithLatePtAssignment) { 4130 FieldTrials field_trials = 4131 CreateTestFieldTrials("WebRTC-PayloadTypesInTransport/Enabled/"); 4132 Environment env = CreateEnvironment(&field_trials); 4133 4134 for (bool use_null_apm : {false, true}) { 4135 std::vector<webrtc::AudioCodecSpec> specs; 4136 webrtc::AudioCodecSpec spec1 = { 4137 .format = {"codec1", 48000, 2, {{"param1", "value1"}}}, 4138 .info = {48000, 2, 16000, 10000, 20000}}; 4139 spec1.info.allow_comfort_noise = false; 4140 spec1.info.supports_network_adaption = true; 4141 specs.push_back(spec1); 4142 webrtc::AudioCodecSpec spec2 = { 4143 .format = {"codec2", 48000, 2, {{"param1", "value1"}}}, 4144 .info = {48000, 2, 16000, 10000, 20000}}; 4145 // We do not support 48khz CN. 4146 spec2.info.allow_comfort_noise = true; 4147 specs.push_back(spec2); 4148 specs.push_back({.format = {"codec3", 8000, 1}, .info = {8000, 1, 64000}}); 4149 specs.push_back({.format = {"codec4", 8000, 2}, .info = {8000, 1, 64000}}); 4150 4151 webrtc::scoped_refptr<webrtc::MockAudioEncoderFactory> 4152 unused_encoder_factory = 4153 webrtc::MockAudioEncoderFactory::CreateUnusedFactory(); 4154 webrtc::scoped_refptr<webrtc::MockAudioDecoderFactory> 4155 mock_decoder_factory = 4156 webrtc::make_ref_counted<webrtc::MockAudioDecoderFactory>(); 4157 EXPECT_CALL(*mock_decoder_factory.get(), GetSupportedDecoders()) 4158 .WillOnce(Return(specs)); 4159 webrtc::scoped_refptr<webrtc::test::MockAudioDeviceModule> adm = 4160 webrtc::test::MockAudioDeviceModule::CreateNice(); 4161 4162 scoped_refptr<AudioProcessing> apm = 4163 use_null_apm ? nullptr : BuiltinAudioProcessingBuilder().Build(env); 4164 webrtc::WebRtcVoiceEngine engine(env, adm, unused_encoder_factory, 4165 mock_decoder_factory, nullptr, apm, 4166 nullptr); 4167 engine.Init(); 4168 auto codecs = engine.LegacyRecvCodecs(); 4169 EXPECT_EQ(7u, codecs.size()); 4170 4171 // Rather than just ASSERTing that there are enough codecs, ensure that we 4172 // can check the actual values safely, to provide better test results. 4173 auto get_codec = [&codecs](size_t index) -> const webrtc::Codec& { 4174 static const webrtc::Codec missing_codec = webrtc::CreateAudioCodec( 4175 0, "<missing>", webrtc::kDefaultAudioClockRateHz, 0); 4176 if (codecs.size() > index) 4177 return codecs[index]; 4178 return missing_codec; 4179 }; 4180 4181 // Ensure the general codecs are generated first and in order. 4182 for (size_t i = 0; i != specs.size(); ++i) { 4183 EXPECT_EQ(specs[i].format.name, get_codec(i).name); 4184 EXPECT_EQ(specs[i].format.clockrate_hz, get_codec(i).clockrate); 4185 EXPECT_EQ(specs[i].format.num_channels, get_codec(i).channels); 4186 EXPECT_EQ(specs[i].format.parameters, get_codec(i).params); 4187 } 4188 4189 // Find the index of a codec, or -1 if not found, so that we can easily 4190 // check supplementary codecs are ordered after the general codecs. 4191 auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int { 4192 for (size_t i = 0; i != codecs.size(); ++i) { 4193 const webrtc::Codec& codec = codecs[i]; 4194 if (absl::EqualsIgnoreCase(codec.name, format.name) && 4195 codec.clockrate == format.clockrate_hz && 4196 codec.channels == format.num_channels) { 4197 return webrtc::checked_cast<int>(i); 4198 } 4199 } 4200 return -1; 4201 }; 4202 4203 // Ensure all supplementary codecs are generated last. Their internal 4204 // ordering is not important. Without this cast, the comparison turned 4205 // unsigned and, thus, failed for -1. 4206 const int num_specs = static_cast<int>(specs.size()); 4207 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); 4208 EXPECT_EQ(find_codec({"cn", 16000, 1}), -1); 4209 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); 4210 EXPECT_EQ(find_codec({"cn", 48000, 1}), -1); 4211 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); 4212 EXPECT_EQ(find_codec({"telephone-event", 16000, 1}), -1); 4213 EXPECT_EQ(find_codec({"telephone-event", 32000, 1}), -1); 4214 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); 4215 } 4216 } 4217 4218 } // namespace 4219 } // namespace webrtc