audio_send_stream_unittest.cc (43897B)
1 /* 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "audio/audio_send_stream.h" 12 13 #include <array> 14 #include <cstddef> 15 #include <cstdint> 16 #include <memory> 17 #include <optional> 18 #include <string> 19 #include <utility> 20 #include <vector> 21 22 #include "api/audio/audio_frame.h" 23 #include "api/audio/audio_processing_statistics.h" 24 #include "api/audio_codecs/audio_encoder.h" 25 #include "api/audio_codecs/audio_format.h" 26 #include "api/call/bitrate_allocation.h" 27 #include "api/crypto/frame_encryptor_interface.h" 28 #include "api/environment/environment_factory.h" 29 #include "api/field_trials.h" 30 #include "api/function_view.h" 31 #include "api/make_ref_counted.h" 32 #include "api/rtp_parameters.h" 33 #include "api/scoped_refptr.h" 34 #include "api/test/mock_frame_encryptor.h" 35 #include "api/transport/network_types.h" 36 #include "api/units/data_rate.h" 37 #include "api/units/data_size.h" 38 #include "api/units/time_delta.h" 39 #include "audio/audio_state.h" 40 #include "audio/channel_send.h" 41 #include "audio/conversion.h" 42 #include "audio/mock_voe_channel_proxy.h" 43 #include "call/audio_state.h" 44 #include "call/bitrate_allocator.h" 45 #include "call/test/mock_bitrate_allocator.h" 46 #include "call/test/mock_rtp_transport_controller_send.h" 47 #include "modules/audio_device/include/mock_audio_device.h" 48 #include "modules/audio_mixer/audio_mixer_impl.h" 49 #include "modules/audio_mixer/sine_wave_generator.h" 50 #include "modules/audio_processing/include/mock_audio_processing.h" 51 #include "modules/rtp_rtcp/include/report_block_data.h" 52 #include "modules/rtp_rtcp/mocks/mock_network_link_rtcp_observer.h" 53 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" 54 #include "modules/rtp_rtcp/source/rtp_header_extensions.h" 55 #include "test/create_test_field_trials.h" 56 #include "test/gmock.h" 57 #include "test/gtest.h" 58 #include "test/mock_audio_encoder.h" 59 #include "test/mock_audio_encoder_factory.h" 60 #include "test/time_controller/real_time_controller.h" 61 62 namespace webrtc { 63 namespace test { 64 namespace { 65 66 using ::testing::_; 67 using ::testing::AnyNumber; 68 using ::testing::ElementsAreArray; 69 using ::testing::Eq; 70 using ::testing::Field; 71 using ::testing::InSequence; 72 using ::testing::Invoke; 73 using ::testing::Ne; 74 using ::testing::NiceMock; 75 using ::testing::Return; 76 using ::testing::StrEq; 77 using ::testing::WithArg; 78 79 constexpr float kTolerance = 0.0001f; 80 81 constexpr uint32_t kSsrc = 1234; 82 constexpr char kCName[] = "foo_name"; 83 constexpr std::array<uint32_t, 2> kCsrcs = {5678, 9012}; 84 constexpr int kAudioLevelId = 2; 85 constexpr int kTransportSequenceNumberId = 4; 86 constexpr int32_t kEchoDelayMedian = 254; 87 constexpr int32_t kEchoDelayStdDev = -3; 88 constexpr double kDivergentFilterFraction = 0.2f; 89 constexpr double kEchoReturnLoss = -65; 90 constexpr double kEchoReturnLossEnhancement = 101; 91 constexpr double kResidualEchoLikelihood = -1.0f; 92 constexpr double kResidualEchoLikelihoodMax = 23.0f; 93 constexpr ChannelSendStatistics kChannelStats = { 94 .round_trip_time = TimeDelta::Millis(112), 95 .payload_bytes_sent = 12, 96 .header_and_padding_bytes_sent = 13456, 97 .retransmitted_bytes_sent = 17890}; 98 constexpr int kFractionLost = 123; 99 constexpr int kCumulativeLost = 567; 100 constexpr uint32_t kInterarrivalJitter = 132; 101 constexpr int kTelephoneEventPayloadType = 123; 102 constexpr int kTelephoneEventPayloadFrequency = 65432; 103 constexpr int kTelephoneEventCode = 45; 104 constexpr int kTelephoneEventDuration = 6789; 105 constexpr int kIsacPayloadType = 103; 106 const SdpAudioFormat kIsacFormat = {"isac", 16000, 1}; 107 const SdpAudioFormat kOpusFormat = {"opus", 48000, 2}; 108 const SdpAudioFormat kG722Format = {"g722", 8000, 1}; 109 const AudioCodecSpec kCodecSpecs[] = { 110 {.format = kIsacFormat, .info = {16000, 1, 32000, 10000, 32000}}, 111 {.format = kOpusFormat, .info = {48000, 1, 32000, 6000, 510000}}, 112 {.format = kG722Format, .info = {16000, 1, 64000}}}; 113 114 // TODO(dklee): This mirrors calculation in audio_send_stream.cc, which 115 // should be made more precise in the future. This can be changed when that 116 // logic is more accurate. 117 constexpr DataSize kOverheadPerPacket = DataSize::Bytes(20 + 8 + 10 + 12); 118 constexpr TimeDelta kMinFrameLength = TimeDelta::Millis(20); 119 constexpr TimeDelta kMaxFrameLength = TimeDelta::Millis(120); 120 constexpr DataRate kMinOverheadRate = kOverheadPerPacket / kMaxFrameLength; 121 constexpr DataRate kMaxOverheadRate = kOverheadPerPacket / kMinFrameLength; 122 123 class MockLimitObserver : public BitrateAllocator::LimitObserver { 124 public: 125 MOCK_METHOD(void, 126 OnAllocationLimitsChanged, 127 (BitrateAllocationLimits), 128 (override)); 129 }; 130 131 std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock( 132 const SdpAudioFormat& format) { 133 for (const auto& spec : kCodecSpecs) { 134 if (format == spec.format) { 135 auto encoder = std::make_unique<NiceMock<MockAudioEncoder>>(); 136 ON_CALL(*encoder, SampleRateHz) 137 .WillByDefault(Return(spec.info.sample_rate_hz)); 138 ON_CALL(*encoder, NumChannels) 139 .WillByDefault(Return(spec.info.num_channels)); 140 ON_CALL(*encoder, RtpTimestampRateHz) 141 .WillByDefault(Return(spec.format.clockrate_hz)); 142 ON_CALL(*encoder, GetFrameLengthRange) 143 .WillByDefault(Return( 144 std::make_pair(TimeDelta::Millis(20), TimeDelta::Millis(120)))); 145 return encoder; 146 } 147 } 148 return nullptr; 149 } 150 151 scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() { 152 scoped_refptr<MockAudioEncoderFactory> factory = 153 make_ref_counted<MockAudioEncoderFactory>(); 154 ON_CALL(*factory, GetSupportedEncoders) 155 .WillByDefault(Return(std::vector<AudioCodecSpec>( 156 std::begin(kCodecSpecs), std::end(kCodecSpecs)))); 157 ON_CALL(*factory, QueryAudioEncoder) 158 .WillByDefault( 159 [](const SdpAudioFormat& format) -> std::optional<AudioCodecInfo> { 160 for (const auto& spec : kCodecSpecs) { 161 if (format == spec.format) { 162 return spec.info; 163 } 164 } 165 return std::nullopt; 166 }); 167 ON_CALL(*factory, Create).WillByDefault(WithArg<1>(&SetupAudioEncoderMock)); 168 return factory; 169 } 170 171 class ConfigHelper { 172 public: 173 ConfigHelper(bool audio_bwe_enabled, 174 bool expect_set_encoder_call, 175 bool use_null_audio_processing) 176 : field_trials_(CreateTestFieldTrials()), 177 stream_config_(/*send_transport=*/nullptr), 178 audio_processing_( 179 use_null_audio_processing 180 ? nullptr 181 : make_ref_counted<NiceMock<MockAudioProcessing>>()), 182 audio_encoder_(nullptr) { 183 AudioState::Config config; 184 config.audio_mixer = AudioMixerImpl::Create(); 185 config.audio_processing = audio_processing_; 186 config.audio_device_module = make_ref_counted<MockAudioDeviceModule>(); 187 audio_state_ = AudioState::Create(config); 188 189 SetupDefaultChannelSend(audio_bwe_enabled); 190 SetupMockForSetupSendCodec(expect_set_encoder_call); 191 SetupMockForCallEncoder(); 192 193 // Use ISAC as default codec so as to prevent unnecessary `channel_proxy_` 194 // calls from the default ctor behavior. 195 stream_config_.send_codec_spec = 196 AudioSendStream::Config::SendCodecSpec(kIsacPayloadType, kIsacFormat); 197 stream_config_.rtp.ssrc = kSsrc; 198 stream_config_.rtp.csrcs.assign(kCsrcs.begin(), kCsrcs.end()); 199 stream_config_.rtp.c_name = kCName; 200 stream_config_.rtp.extensions.push_back( 201 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); 202 stream_config_.include_in_congestion_control_allocation = audio_bwe_enabled; 203 204 stream_config_.encoder_factory = SetupEncoderFactoryMock(); 205 stream_config_.min_bitrate_bps = 10000; 206 stream_config_.max_bitrate_bps = 65000; 207 } 208 209 std::unique_ptr<internal::AudioSendStream> CreateAudioSendStream() { 210 return std::make_unique<internal::AudioSendStream>( 211 CreateEnvironment(&field_trials_, time_controller_.GetClock(), 212 time_controller_.GetTaskQueueFactory()), 213 stream_config_, audio_state_, &rtp_transport_, &bitrate_allocator_, 214 std::nullopt, 215 std::unique_ptr<voe::ChannelSendInterface>(channel_send_)); 216 } 217 218 AudioSendStream::Config& config() { return stream_config_; } 219 MockAudioEncoderFactory& mock_encoder_factory() { 220 return *static_cast<MockAudioEncoderFactory*>( 221 stream_config_.encoder_factory.get()); 222 } 223 MockRtpRtcpInterface* rtp_rtcp() { return &rtp_rtcp_; } 224 MockChannelSend* channel_send() { return channel_send_; } 225 RtpTransportControllerSendInterface* transport() { return &rtp_transport_; } 226 MockBitrateAllocator* bitrate_allocator() { return &bitrate_allocator_; } 227 228 void SetupDefaultChannelSend(bool audio_bwe_enabled) { 229 EXPECT_TRUE(channel_send_ == nullptr); 230 channel_send_ = new ::testing::StrictMock<MockChannelSend>(); 231 EXPECT_CALL(*channel_send_, GetRtpRtcp()).WillRepeatedly(Invoke([this]() { 232 return &this->rtp_rtcp_; 233 })); 234 EXPECT_CALL(rtp_rtcp_, SSRC).WillRepeatedly(Return(kSsrc)); 235 EXPECT_CALL(*channel_send_, SetRTCP_CNAME(StrEq(kCName))).Times(1); 236 EXPECT_CALL(*channel_send_, SetFrameEncryptor(_)).Times(1); 237 EXPECT_CALL(*channel_send_, SetEncoderToPacketizerFrameTransformer(_)) 238 .Times(1); 239 EXPECT_CALL(rtp_rtcp_, SetExtmapAllowMixed(false)).Times(1); 240 EXPECT_CALL(*channel_send_, SetCsrcs(ElementsAreArray(kCsrcs))).Times(1); 241 EXPECT_CALL(*channel_send_, 242 SetSendAudioLevelIndicationStatus(true, kAudioLevelId)) 243 .Times(1); 244 EXPECT_CALL(rtp_transport_, GetRtcpObserver) 245 .WillRepeatedly(Return(&rtcp_observer_)); 246 EXPECT_CALL(*channel_send_, 247 RegisterSenderCongestionControlObjects(&rtp_transport_)) 248 .Times(1); 249 EXPECT_CALL(*channel_send_, ResetSenderCongestionControlObjects()).Times(1); 250 } 251 252 void SetupMockForSetupSendCodec(bool expect_set_encoder_call) { 253 if (expect_set_encoder_call) { 254 EXPECT_CALL(*channel_send_, SetEncoder) 255 .WillOnce([this](int /* payload_type */, 256 const SdpAudioFormat& /* format */, 257 std::unique_ptr<AudioEncoder> encoder) { 258 this->audio_encoder_ = std::move(encoder); 259 return true; 260 }); 261 } 262 } 263 264 void SetupMockForCallEncoder() { 265 // Let ModifyEncoder to invoke mock audio encoder. 266 EXPECT_CALL(*channel_send_, CallEncoder(_)) 267 .WillRepeatedly([this](FunctionView<void(AudioEncoder*)> modifier) { 268 if (this->audio_encoder_) 269 modifier(this->audio_encoder_.get()); 270 }); 271 } 272 273 void SetupMockForSendTelephoneEvent() { 274 EXPECT_TRUE(channel_send_); 275 EXPECT_CALL(*channel_send_, SetSendTelephoneEventPayloadType( 276 kTelephoneEventPayloadType, 277 kTelephoneEventPayloadFrequency)); 278 EXPECT_CALL( 279 *channel_send_, 280 SendTelephoneEventOutband(kTelephoneEventCode, kTelephoneEventDuration)) 281 .WillOnce(Return(true)); 282 } 283 284 void SetupMockForGetStats(bool use_null_audio_processing) { 285 using ::testing::DoAll; 286 using ::testing::SetArgPointee; 287 using ::testing::SetArgReferee; 288 289 std::vector<ReportBlockData> report_blocks; 290 ReportBlockData block; 291 block.set_source_ssrc(780); 292 block.set_fraction_lost_raw(kFractionLost); 293 block.set_cumulative_lost(kCumulativeLost); 294 block.set_jitter(kInterarrivalJitter); 295 report_blocks.push_back(block); // Has wrong SSRC. 296 block.set_source_ssrc(kSsrc); 297 report_blocks.push_back(block); // Correct block. 298 block.set_fraction_lost_raw(0); 299 report_blocks.push_back(block); // Duplicate SSRC, bad fraction_lost. 300 301 EXPECT_TRUE(channel_send_); 302 EXPECT_CALL(*channel_send_, GetRTCPStatistics()) 303 .WillRepeatedly(Return(kChannelStats)); 304 EXPECT_CALL(*channel_send_, GetRemoteRTCPReportBlocks()) 305 .WillRepeatedly(Return(report_blocks)); 306 EXPECT_CALL(*channel_send_, GetANAStatistics()) 307 .WillRepeatedly(Return(ANAStats())); 308 EXPECT_CALL(*channel_send_, GetTargetBitrate()).WillRepeatedly(Return(0)); 309 310 audio_processing_stats_.echo_return_loss = kEchoReturnLoss; 311 audio_processing_stats_.echo_return_loss_enhancement = 312 kEchoReturnLossEnhancement; 313 audio_processing_stats_.delay_median_ms = kEchoDelayMedian; 314 audio_processing_stats_.delay_standard_deviation_ms = kEchoDelayStdDev; 315 audio_processing_stats_.divergent_filter_fraction = 316 kDivergentFilterFraction; 317 audio_processing_stats_.residual_echo_likelihood = kResidualEchoLikelihood; 318 audio_processing_stats_.residual_echo_likelihood_recent_max = 319 kResidualEchoLikelihoodMax; 320 if (!use_null_audio_processing) { 321 ASSERT_TRUE(audio_processing_); 322 EXPECT_CALL(*audio_processing_, GetStatistics(true)) 323 .WillRepeatedly(Return(audio_processing_stats_)); 324 } 325 } 326 327 FieldTrials& field_trials() { return field_trials_; } 328 329 private: 330 FieldTrials field_trials_; 331 RealTimeController time_controller_; 332 scoped_refptr<AudioState> audio_state_; 333 AudioSendStream::Config stream_config_; 334 ::testing::StrictMock<MockChannelSend>* channel_send_ = nullptr; 335 scoped_refptr<MockAudioProcessing> audio_processing_; 336 AudioProcessingStats audio_processing_stats_; 337 ::testing::StrictMock<MockNetworkLinkRtcpObserver> rtcp_observer_; 338 ::testing::NiceMock<MockRtpTransportControllerSend> rtp_transport_; 339 ::testing::NiceMock<MockRtpRtcpInterface> rtp_rtcp_; 340 ::testing::NiceMock<MockLimitObserver> limit_observer_; 341 ::testing::NiceMock<MockBitrateAllocator> bitrate_allocator_; 342 std::unique_ptr<AudioEncoder> audio_encoder_; 343 }; 344 345 // The audio level ranges linearly [0,32767]. 346 std::unique_ptr<AudioFrame> CreateAudioFrame1kHzSineWave(int16_t audio_level, 347 int duration_ms, 348 int sample_rate_hz, 349 size_t num_channels) { 350 size_t samples_per_channel = sample_rate_hz / (1000 / duration_ms); 351 std::vector<int16_t> audio_data(samples_per_channel * num_channels, 0); 352 std::unique_ptr<AudioFrame> audio_frame = std::make_unique<AudioFrame>(); 353 audio_frame->UpdateFrame(0 /* RTP timestamp */, &audio_data[0], 354 samples_per_channel, sample_rate_hz, 355 AudioFrame::SpeechType::kNormalSpeech, 356 AudioFrame::VADActivity::kVadUnknown, num_channels); 357 SineWaveGenerator wave_generator(1000.0, audio_level); 358 wave_generator.GenerateNextFrame(audio_frame.get()); 359 return audio_frame; 360 } 361 362 } // namespace 363 364 TEST(AudioSendStreamTest, ConfigToString) { 365 AudioSendStream::Config config(/*send_transport=*/nullptr); 366 config.rtp.ssrc = kSsrc; 367 config.rtp.csrcs.assign(kCsrcs.begin(), kCsrcs.end()); 368 config.rtp.c_name = kCName; 369 config.min_bitrate_bps = 12000; 370 config.max_bitrate_bps = 34000; 371 config.has_dscp = true; 372 config.send_codec_spec = 373 AudioSendStream::Config::SendCodecSpec(kIsacPayloadType, kIsacFormat); 374 config.send_codec_spec->nack_enabled = true; 375 config.send_codec_spec->cng_payload_type = 42; 376 config.send_codec_spec->red_payload_type = 43; 377 config.encoder_factory = MockAudioEncoderFactory::CreateUnusedFactory(); 378 config.rtp.extmap_allow_mixed = true; 379 config.rtp.extensions.push_back( 380 RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId)); 381 config.rtcp_report_interval_ms = 2500; 382 EXPECT_EQ( 383 "{rtp: {ssrc: 1234, csrcs: [5678, 9012], extmap-allow-mixed: true, " 384 "extensions: [{uri: urn:ietf:params:rtp-hdrext:ssrc-audio-level, " 385 "id: 2}], c_name: foo_name}, rtcp_report_interval_ms: 2500, " 386 "send_transport: null, " 387 "min_bitrate_bps: 12000, max_bitrate_bps: 34000, has " 388 "audio_network_adaptor_config: false, has_dscp: true, " 389 "send_codec_spec: {nack_enabled: true, " 390 "enable_non_sender_rtt: false, cng_payload_type: 42, " 391 "red_payload_type: 43, payload_type: 103, " 392 "format: {name: isac, clockrate_hz: 16000, num_channels: 1, " 393 "parameters: {}}}}", 394 config.ToString()); 395 } 396 397 TEST(AudioSendStreamTest, ConstructDestruct) { 398 for (bool use_null_audio_processing : {false, true}) { 399 ConfigHelper helper(false, true, use_null_audio_processing); 400 auto send_stream = helper.CreateAudioSendStream(); 401 } 402 } 403 404 TEST(AudioSendStreamTest, SendTelephoneEvent) { 405 for (bool use_null_audio_processing : {false, true}) { 406 ConfigHelper helper(false, true, use_null_audio_processing); 407 auto send_stream = helper.CreateAudioSendStream(); 408 helper.SetupMockForSendTelephoneEvent(); 409 EXPECT_TRUE(send_stream->SendTelephoneEvent( 410 kTelephoneEventPayloadType, kTelephoneEventPayloadFrequency, 411 kTelephoneEventCode, kTelephoneEventDuration)); 412 } 413 } 414 415 TEST(AudioSendStreamTest, SetMuted) { 416 for (bool use_null_audio_processing : {false, true}) { 417 ConfigHelper helper(false, true, use_null_audio_processing); 418 auto send_stream = helper.CreateAudioSendStream(); 419 EXPECT_CALL(*helper.channel_send(), SetInputMute(true)); 420 send_stream->SetMuted(true); 421 } 422 } 423 424 TEST(AudioSendStreamTest, SetCsrcs) { 425 for (bool use_null_audio_processing : {false, true}) { 426 ConfigHelper helper(false, true, use_null_audio_processing); 427 auto send_stream = helper.CreateAudioSendStream(); 428 429 std::vector<uint32_t> updated_csrcs = {4, 5, 6}; 430 helper.config().rtp.csrcs = updated_csrcs; 431 EXPECT_CALL(*helper.channel_send(), 432 SetCsrcs(ElementsAreArray(updated_csrcs))); 433 send_stream->Reconfigure(helper.config(), nullptr); 434 } 435 } 436 437 TEST(AudioSendStreamTest, AudioBweCorrectObjectsOnChannelProxy) { 438 for (bool use_null_audio_processing : {false, true}) { 439 ConfigHelper helper(true, true, use_null_audio_processing); 440 auto send_stream = helper.CreateAudioSendStream(); 441 } 442 } 443 444 TEST(AudioSendStreamTest, NoAudioBweCorrectObjectsOnChannelProxy) { 445 for (bool use_null_audio_processing : {false, true}) { 446 ConfigHelper helper(false, true, use_null_audio_processing); 447 auto send_stream = helper.CreateAudioSendStream(); 448 } 449 } 450 451 TEST(AudioSendStreamTest, GetStats) { 452 for (bool use_null_audio_processing : {false, true}) { 453 ConfigHelper helper(false, true, use_null_audio_processing); 454 auto send_stream = helper.CreateAudioSendStream(); 455 helper.SetupMockForGetStats(use_null_audio_processing); 456 AudioSendStream::Stats stats = send_stream->GetStats(true); 457 EXPECT_EQ(kSsrc, stats.local_ssrc); 458 EXPECT_EQ(kChannelStats.payload_bytes_sent, stats.payload_bytes_sent); 459 EXPECT_EQ(kChannelStats.header_and_padding_bytes_sent, 460 stats.header_and_padding_bytes_sent); 461 EXPECT_EQ(kChannelStats.packets_sent, stats.packets_sent); 462 EXPECT_EQ(stats.packets_lost, kCumulativeLost); 463 EXPECT_FLOAT_EQ(stats.fraction_lost, Q8ToFloat(kFractionLost)); 464 EXPECT_EQ(kIsacFormat.name, stats.codec_name); 465 EXPECT_EQ(stats.jitter_ms, 466 static_cast<int32_t>(kInterarrivalJitter / 467 (kIsacFormat.clockrate_hz / 1000))); 468 EXPECT_EQ(kChannelStats.round_trip_time.ms(), stats.rtt_ms); 469 EXPECT_EQ(0, stats.audio_level); 470 EXPECT_EQ(0, stats.total_input_energy); 471 EXPECT_EQ(0, stats.total_input_duration); 472 473 if (!use_null_audio_processing) { 474 EXPECT_EQ(kEchoDelayMedian, stats.apm_statistics.delay_median_ms); 475 EXPECT_EQ(kEchoDelayStdDev, 476 stats.apm_statistics.delay_standard_deviation_ms); 477 EXPECT_EQ(kEchoReturnLoss, stats.apm_statistics.echo_return_loss); 478 EXPECT_EQ(kEchoReturnLossEnhancement, 479 stats.apm_statistics.echo_return_loss_enhancement); 480 EXPECT_EQ(kDivergentFilterFraction, 481 stats.apm_statistics.divergent_filter_fraction); 482 EXPECT_EQ(kResidualEchoLikelihood, 483 stats.apm_statistics.residual_echo_likelihood); 484 EXPECT_EQ(kResidualEchoLikelihoodMax, 485 stats.apm_statistics.residual_echo_likelihood_recent_max); 486 } 487 } 488 } 489 490 TEST(AudioSendStreamTest, GetStatsAudioLevel) { 491 for (bool use_null_audio_processing : {false, true}) { 492 ConfigHelper helper(false, true, use_null_audio_processing); 493 auto send_stream = helper.CreateAudioSendStream(); 494 helper.SetupMockForGetStats(use_null_audio_processing); 495 EXPECT_CALL(*helper.channel_send(), ProcessAndEncodeAudio) 496 .Times(AnyNumber()); 497 498 constexpr int kSampleRateHz = 48000; 499 constexpr size_t kNumChannels = 1; 500 501 constexpr int16_t kSilentAudioLevel = 0; 502 constexpr int16_t kMaxAudioLevel = 32767; // Audio level is [0,32767]. 503 constexpr int kAudioFrameDurationMs = 10; 504 505 // Process 10 audio frames (100 ms) of silence. After this, on the next 506 // (11-th) frame, the audio level will be updated with the maximum audio 507 // level of the first 11 frames. See AudioLevel. 508 for (size_t i = 0; i < 10; ++i) { 509 send_stream->SendAudioData( 510 CreateAudioFrame1kHzSineWave(kSilentAudioLevel, kAudioFrameDurationMs, 511 kSampleRateHz, kNumChannels)); 512 } 513 AudioSendStream::Stats stats = send_stream->GetStats(); 514 EXPECT_EQ(kSilentAudioLevel, stats.audio_level); 515 EXPECT_NEAR(0.0f, stats.total_input_energy, kTolerance); 516 EXPECT_NEAR(0.1f, stats.total_input_duration, 517 kTolerance); // 100 ms = 0.1 s 518 519 // Process 10 audio frames (100 ms) of maximum audio level. 520 // Note that AudioLevel updates the audio level every 11th frame, processing 521 // 10 frames above was needed to see a non-zero audio level here. 522 for (size_t i = 0; i < 10; ++i) { 523 send_stream->SendAudioData(CreateAudioFrame1kHzSineWave( 524 kMaxAudioLevel, kAudioFrameDurationMs, kSampleRateHz, kNumChannels)); 525 } 526 stats = send_stream->GetStats(); 527 EXPECT_EQ(kMaxAudioLevel, stats.audio_level); 528 // Energy increases by energy*duration, where energy is audio level in 529 // [0,1]. 530 EXPECT_NEAR(0.1f, stats.total_input_energy, kTolerance); // 0.1 s of max 531 EXPECT_NEAR(0.2f, stats.total_input_duration, 532 kTolerance); // 200 ms = 0.2 s 533 } 534 } 535 536 TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) { 537 for (bool use_null_audio_processing : {false, true}) { 538 ConfigHelper helper(true, true, use_null_audio_processing); 539 helper.config().send_codec_spec = 540 AudioSendStream::Config::SendCodecSpec(0, kOpusFormat); 541 const std::string kAnaConfigString = "abcde"; 542 const std::string kAnaReconfigString = "12345"; 543 544 helper.config().audio_network_adaptor_config = kAnaConfigString; 545 546 EXPECT_CALL(helper.mock_encoder_factory(), Create) 547 .WillOnce(WithArg<1>([&kAnaConfigString, &kAnaReconfigString]( 548 const SdpAudioFormat& format) { 549 auto mock_encoder = SetupAudioEncoderMock(format); 550 EXPECT_CALL(*mock_encoder, 551 EnableAudioNetworkAdaptor(StrEq(kAnaConfigString))) 552 .WillOnce(Return(true)); 553 EXPECT_CALL(*mock_encoder, 554 EnableAudioNetworkAdaptor(StrEq(kAnaReconfigString))) 555 .WillOnce(Return(true)); 556 return mock_encoder; 557 })); 558 559 auto send_stream = helper.CreateAudioSendStream(); 560 561 auto stream_config = helper.config(); 562 stream_config.audio_network_adaptor_config = kAnaReconfigString; 563 564 send_stream->Reconfigure(stream_config, nullptr); 565 } 566 } 567 568 TEST(AudioSendStreamTest, AudioNetworkAdaptorReceivesOverhead) { 569 for (bool use_null_audio_processing : {false, true}) { 570 ConfigHelper helper(true, true, use_null_audio_processing); 571 helper.config().send_codec_spec = 572 AudioSendStream::Config::SendCodecSpec(0, kOpusFormat); 573 const std::string kAnaConfigString = "abcde"; 574 575 EXPECT_CALL(helper.mock_encoder_factory(), Create) 576 .WillOnce(WithArg<1>([&kAnaConfigString](const SdpAudioFormat& format) { 577 auto mock_encoder = SetupAudioEncoderMock(format); 578 InSequence s; 579 EXPECT_CALL( 580 *mock_encoder, 581 OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>()))); 582 EXPECT_CALL(*mock_encoder, 583 EnableAudioNetworkAdaptor(StrEq(kAnaConfigString))) 584 .WillOnce(Return(true)); 585 // Note: Overhead is received AFTER ANA has been enabled. 586 EXPECT_CALL( 587 *mock_encoder, 588 OnReceivedOverhead(Eq(kOverheadPerPacket.bytes<size_t>()))); 589 return mock_encoder; 590 })); 591 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 592 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>())); 593 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead); 594 595 auto send_stream = helper.CreateAudioSendStream(); 596 597 auto stream_config = helper.config(); 598 stream_config.audio_network_adaptor_config = kAnaConfigString; 599 600 send_stream->Reconfigure(stream_config, nullptr); 601 } 602 } 603 604 // VAD is applied when codec is mono and the CNG frequency matches the codec 605 // clock rate. 606 TEST(AudioSendStreamTest, SendCodecCanApplyVad) { 607 for (bool use_null_audio_processing : {false, true}) { 608 ConfigHelper helper(false, false, use_null_audio_processing); 609 helper.config().send_codec_spec = 610 AudioSendStream::Config::SendCodecSpec(9, kG722Format); 611 helper.config().send_codec_spec->cng_payload_type = 105; 612 std::unique_ptr<AudioEncoder> stolen_encoder; 613 EXPECT_CALL(*helper.channel_send(), SetEncoder) 614 .WillOnce([&stolen_encoder](int /* payload_type */, 615 const SdpAudioFormat& /* format */, 616 std::unique_ptr<AudioEncoder> encoder) { 617 stolen_encoder = std::move(encoder); 618 return true; 619 }); 620 EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000)); 621 622 auto send_stream = helper.CreateAudioSendStream(); 623 624 // We cannot truly determine if the encoder created is an AudioEncoderCng. 625 // It is the only reasonable implementation that will return something from 626 // ReclaimContainedEncoders, though. 627 ASSERT_TRUE(stolen_encoder); 628 EXPECT_FALSE(stolen_encoder->ReclaimContainedEncoders().empty()); 629 } 630 } 631 632 TEST(AudioSendStreamTest, DoesNotPassHigherBitrateThanMaxBitrate) { 633 for (bool use_null_audio_processing : {false, true}) { 634 ConfigHelper helper(false, true, use_null_audio_processing); 635 auto send_stream = helper.CreateAudioSendStream(); 636 EXPECT_CALL( 637 *helper.channel_send(), 638 OnBitrateAllocation( 639 Field(&BitrateAllocationUpdate::target_bitrate, 640 Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps))))); 641 BitrateAllocationUpdate update; 642 update.target_bitrate = 643 DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000); 644 update.packet_loss_ratio = 0; 645 update.round_trip_time = TimeDelta::Millis(50); 646 update.bwe_period = TimeDelta::Millis(6000); 647 send_stream->OnBitrateUpdated(update); 648 } 649 } 650 651 TEST(AudioSendStreamTest, SSBweTargetInRangeRespected) { 652 for (bool use_null_audio_processing : {false, true}) { 653 ConfigHelper helper(true, true, use_null_audio_processing); 654 auto send_stream = helper.CreateAudioSendStream(); 655 EXPECT_CALL( 656 *helper.channel_send(), 657 OnBitrateAllocation(Field( 658 &BitrateAllocationUpdate::target_bitrate, 659 Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000))))); 660 BitrateAllocationUpdate update; 661 update.target_bitrate = 662 DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000); 663 send_stream->OnBitrateUpdated(update); 664 } 665 } 666 667 TEST(AudioSendStreamTest, SSBweFieldTrialMinRespected) { 668 for (bool use_null_audio_processing : {false, true}) { 669 ConfigHelper helper(true, true, use_null_audio_processing); 670 helper.field_trials().Set("WebRTC-Audio-Allocation", 671 "min:6kbps,max:64kbps"); 672 auto send_stream = helper.CreateAudioSendStream(); 673 EXPECT_CALL( 674 *helper.channel_send(), 675 OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate, 676 Eq(DataRate::KilobitsPerSec(6))))); 677 BitrateAllocationUpdate update; 678 update.target_bitrate = DataRate::KilobitsPerSec(1); 679 send_stream->OnBitrateUpdated(update); 680 } 681 } 682 683 TEST(AudioSendStreamTest, SSBweFieldTrialMaxRespected) { 684 for (bool use_null_audio_processing : {false, true}) { 685 ConfigHelper helper(true, true, use_null_audio_processing); 686 helper.field_trials().Set("WebRTC-Audio-Allocation", 687 "min:6kbps,max:64kbps"); 688 auto send_stream = helper.CreateAudioSendStream(); 689 EXPECT_CALL( 690 *helper.channel_send(), 691 OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate, 692 Eq(DataRate::KilobitsPerSec(64))))); 693 BitrateAllocationUpdate update; 694 update.target_bitrate = DataRate::KilobitsPerSec(128); 695 send_stream->OnBitrateUpdated(update); 696 } 697 } 698 699 TEST(AudioSendStreamTest, SSBweWithOverhead) { 700 for (bool use_null_audio_processing : {false, true}) { 701 ConfigHelper helper(true, true, use_null_audio_processing); 702 helper.field_trials().Set("WebRTC-Audio-LegacyOverhead", "Disabled"); 703 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 704 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>())); 705 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead); 706 auto send_stream = helper.CreateAudioSendStream(); 707 const DataRate bitrate = 708 DataRate::BitsPerSec(helper.config().max_bitrate_bps) + 709 kMaxOverheadRate; 710 EXPECT_CALL(*helper.channel_send(), 711 OnBitrateAllocation(Field( 712 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); 713 BitrateAllocationUpdate update; 714 update.target_bitrate = bitrate; 715 send_stream->OnBitrateUpdated(update); 716 } 717 } 718 719 TEST(AudioSendStreamTest, SSBweWithOverheadMinRespected) { 720 for (bool use_null_audio_processing : {false, true}) { 721 ConfigHelper helper(true, true, use_null_audio_processing); 722 helper.field_trials().Set("WebRTC-Audio-LegacyOverhead", "Disabled"); 723 helper.field_trials().Set("WebRTC-Audio-Allocation", 724 "min:6kbps,max:64kbps"); 725 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 726 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>())); 727 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead); 728 auto send_stream = helper.CreateAudioSendStream(); 729 const DataRate bitrate = DataRate::KilobitsPerSec(6) + kMinOverheadRate; 730 EXPECT_CALL(*helper.channel_send(), 731 OnBitrateAllocation(Field( 732 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); 733 BitrateAllocationUpdate update; 734 update.target_bitrate = DataRate::KilobitsPerSec(1); 735 send_stream->OnBitrateUpdated(update); 736 } 737 } 738 739 TEST(AudioSendStreamTest, SSBweWithOverheadMaxRespected) { 740 for (bool use_null_audio_processing : {false, true}) { 741 ConfigHelper helper(true, true, use_null_audio_processing); 742 helper.field_trials().Set("WebRTC-Audio-LegacyOverhead", "Disabled"); 743 helper.field_trials().Set("WebRTC-Audio-Allocation", 744 "min:6kbps,max:64kbps"); 745 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 746 .WillRepeatedly(Return(kOverheadPerPacket.bytes<size_t>())); 747 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead); 748 auto send_stream = helper.CreateAudioSendStream(); 749 const DataRate bitrate = DataRate::KilobitsPerSec(64) + kMaxOverheadRate; 750 EXPECT_CALL(*helper.channel_send(), 751 OnBitrateAllocation(Field( 752 &BitrateAllocationUpdate::target_bitrate, Eq(bitrate)))); 753 BitrateAllocationUpdate update; 754 update.target_bitrate = DataRate::KilobitsPerSec(128); 755 send_stream->OnBitrateUpdated(update); 756 } 757 } 758 759 TEST(AudioSendStreamTest, ProbingIntervalOnBitrateUpdated) { 760 for (bool use_null_audio_processing : {false, true}) { 761 ConfigHelper helper(false, true, use_null_audio_processing); 762 auto send_stream = helper.CreateAudioSendStream(); 763 764 EXPECT_CALL(*helper.channel_send(), 765 OnBitrateAllocation(Field(&BitrateAllocationUpdate::bwe_period, 766 Eq(TimeDelta::Millis(5000))))); 767 BitrateAllocationUpdate update; 768 update.target_bitrate = 769 DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000); 770 update.packet_loss_ratio = 0; 771 update.round_trip_time = TimeDelta::Millis(50); 772 update.bwe_period = TimeDelta::Millis(5000); 773 send_stream->OnBitrateUpdated(update); 774 } 775 } 776 777 // Test that AudioSendStream doesn't recreate the encoder unnecessarily. 778 TEST(AudioSendStreamTest, DontRecreateEncoder) { 779 for (bool use_null_audio_processing : {false, true}) { 780 ConfigHelper helper(false, false, use_null_audio_processing); 781 // WillOnce is (currently) the default used by ConfigHelper if asked to set 782 // an expectation for SetEncoder. Since this behavior is essential for this 783 // test to be correct, it's instead set-up manually here. Otherwise a simple 784 // change to ConfigHelper (say to WillRepeatedly) would silently make this 785 // test useless. 786 EXPECT_CALL(*helper.channel_send(), SetEncoder).WillOnce(Return()); 787 788 EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000)); 789 790 helper.config().send_codec_spec = 791 AudioSendStream::Config::SendCodecSpec(9, kG722Format); 792 helper.config().send_codec_spec->cng_payload_type = 105; 793 auto send_stream = helper.CreateAudioSendStream(); 794 send_stream->Reconfigure(helper.config(), nullptr); 795 } 796 } 797 798 TEST(AudioSendStreamTest, ConfiguresTransportCcIfExtensionNegotiated) { 799 ConfigHelper helper(true, true, false); 800 helper.config().rtp.extensions.push_back(RtpExtension( 801 RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId)); 802 803 EXPECT_CALL(*helper.rtp_rtcp(), 804 RegisterRtpHeaderExtension(TransportSequenceNumber::Uri(), 805 kTransportSequenceNumberId)) 806 .Times(1); 807 auto send_stream = helper.CreateAudioSendStream(); 808 } 809 810 TEST(AudioSendStreamTest, ReconfigureTransportCcResetsFirst) { 811 for (bool use_null_audio_processing : {false, true}) { 812 ConfigHelper helper(false, true, use_null_audio_processing); 813 auto send_stream = helper.CreateAudioSendStream(); 814 auto new_config = helper.config(); 815 new_config.rtp.extensions.push_back(RtpExtension( 816 RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId)); 817 818 EXPECT_CALL(*helper.rtp_rtcp(), 819 RegisterRtpHeaderExtension(TransportSequenceNumber::Uri(), 820 kTransportSequenceNumberId)) 821 .Times(1); 822 { 823 ::testing::InSequence seq; 824 EXPECT_CALL(*helper.channel_send(), ResetSenderCongestionControlObjects()) 825 .Times(1); 826 EXPECT_CALL(*helper.channel_send(), 827 RegisterSenderCongestionControlObjects(helper.transport())) 828 .Times(1); 829 } 830 831 send_stream->Reconfigure(new_config, nullptr); 832 } 833 } 834 835 TEST(AudioSendStreamTest, OnTransportOverheadChanged) { 836 for (bool use_null_audio_processing : {false, true}) { 837 ConfigHelper helper(false, true, use_null_audio_processing); 838 auto send_stream = helper.CreateAudioSendStream(); 839 auto new_config = helper.config(); 840 841 // CallEncoder will be called on overhead change. 842 EXPECT_CALL(*helper.channel_send(), CallEncoder); 843 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead); 844 845 const size_t transport_overhead_per_packet_bytes = 333; 846 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes); 847 848 EXPECT_EQ(transport_overhead_per_packet_bytes, 849 send_stream->TestOnlyGetPerPacketOverheadBytes()); 850 } 851 } 852 853 TEST(AudioSendStreamTest, DoesntCallEncoderWhenOverheadUnchanged) { 854 for (bool use_null_audio_processing : {false, true}) { 855 ConfigHelper helper(false, true, use_null_audio_processing); 856 auto send_stream = helper.CreateAudioSendStream(); 857 auto new_config = helper.config(); 858 859 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2); 860 861 // CallEncoder will be called on overhead change. 862 EXPECT_CALL(*helper.channel_send(), CallEncoder); 863 const size_t transport_overhead_per_packet_bytes = 333; 864 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes); 865 866 // Set the same overhead again, CallEncoder should not be called again. 867 EXPECT_CALL(*helper.channel_send(), CallEncoder).Times(0); 868 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes); 869 870 // New overhead, call CallEncoder again 871 EXPECT_CALL(*helper.channel_send(), CallEncoder); 872 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes + 1); 873 } 874 } 875 876 TEST(AudioSendStreamTest, AudioOverheadChanged) { 877 for (bool use_null_audio_processing : {false, true}) { 878 ConfigHelper helper(false, true, use_null_audio_processing); 879 const size_t audio_overhead_per_packet_bytes = 555; 880 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 881 .WillRepeatedly(Return(audio_overhead_per_packet_bytes)); 882 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2); 883 auto send_stream = helper.CreateAudioSendStream(); 884 885 BitrateAllocationUpdate update; 886 update.target_bitrate = 887 DataRate::BitsPerSec(helper.config().max_bitrate_bps) + 888 kMaxOverheadRate; 889 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); 890 send_stream->OnBitrateUpdated(update); 891 892 EXPECT_EQ(audio_overhead_per_packet_bytes, 893 send_stream->TestOnlyGetPerPacketOverheadBytes()); 894 895 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 896 .WillRepeatedly(Return(audio_overhead_per_packet_bytes + 20)); 897 // RTP overhead can only change in response to RTCP or configuration change. 898 send_stream->Reconfigure(helper.config(), nullptr); 899 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); 900 send_stream->OnBitrateUpdated(update); 901 902 EXPECT_EQ(audio_overhead_per_packet_bytes + 20, 903 send_stream->TestOnlyGetPerPacketOverheadBytes()); 904 } 905 } 906 907 TEST(AudioSendStreamTest, OnAudioAndTransportOverheadChanged) { 908 for (bool use_null_audio_processing : {false, true}) { 909 ConfigHelper helper(false, true, use_null_audio_processing); 910 const size_t audio_overhead_per_packet_bytes = 555; 911 EXPECT_CALL(*helper.rtp_rtcp(), ExpectedPerPacketOverhead) 912 .WillRepeatedly(Return(audio_overhead_per_packet_bytes)); 913 EXPECT_CALL(*helper.channel_send(), RegisterPacketOverhead).Times(2); 914 auto send_stream = helper.CreateAudioSendStream(); 915 auto new_config = helper.config(); 916 917 const size_t transport_overhead_per_packet_bytes = 333; 918 send_stream->SetTransportOverhead(transport_overhead_per_packet_bytes); 919 920 BitrateAllocationUpdate update; 921 update.target_bitrate = 922 DataRate::BitsPerSec(helper.config().max_bitrate_bps) + 923 kMaxOverheadRate; 924 EXPECT_CALL(*helper.channel_send(), OnBitrateAllocation); 925 send_stream->OnBitrateUpdated(update); 926 927 EXPECT_EQ( 928 transport_overhead_per_packet_bytes + audio_overhead_per_packet_bytes, 929 send_stream->TestOnlyGetPerPacketOverheadBytes()); 930 } 931 } 932 933 // Validates that reconfiguring the AudioSendStream with a Frame encryptor 934 // correctly reconfigures on the object without crashing. 935 TEST(AudioSendStreamTest, ReconfigureWithFrameEncryptor) { 936 for (bool use_null_audio_processing : {false, true}) { 937 ConfigHelper helper(false, true, use_null_audio_processing); 938 auto send_stream = helper.CreateAudioSendStream(); 939 auto new_config = helper.config(); 940 941 scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_0( 942 make_ref_counted<MockFrameEncryptor>()); 943 new_config.frame_encryptor = mock_frame_encryptor_0; 944 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr))) 945 .Times(1); 946 send_stream->Reconfigure(new_config, nullptr); 947 948 // Not updating the frame encryptor shouldn't force it to reconfigure. 949 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(_)).Times(0); 950 send_stream->Reconfigure(new_config, nullptr); 951 952 // Updating frame encryptor to a new object should force a call to the 953 // proxy. 954 scoped_refptr<FrameEncryptorInterface> mock_frame_encryptor_1( 955 make_ref_counted<MockFrameEncryptor>()); 956 new_config.frame_encryptor = mock_frame_encryptor_1; 957 new_config.crypto_options.sframe.require_frame_encryption = true; 958 EXPECT_CALL(*helper.channel_send(), SetFrameEncryptor(Ne(nullptr))) 959 .Times(1); 960 send_stream->Reconfigure(new_config, nullptr); 961 } 962 } 963 964 TEST(AudioSendStreamTest, DefaultsHonorsPriorityBitrate) { 965 ConfigHelper helper(true, true, true); 966 helper.field_trials().Set("WebRTC-Audio-Allocation", "prio_rate:20"); 967 auto send_stream = helper.CreateAudioSendStream(); 968 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _)) 969 .WillOnce(Invoke( 970 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) { 971 EXPECT_EQ(config.priority_bitrate_bps, 20000); 972 })); 973 EXPECT_CALL(*helper.channel_send(), StartSend()); 974 send_stream->Start(); 975 EXPECT_CALL(*helper.channel_send(), StopSend()); 976 send_stream->Stop(); 977 } 978 979 TEST(AudioSendStreamTest, DefaultsToContributeUnusedBitrate) { 980 ConfigHelper helper(true, true, true); 981 auto send_stream = helper.CreateAudioSendStream(); 982 EXPECT_CALL( 983 *helper.bitrate_allocator(), 984 AddObserver(send_stream.get(), 985 Field(&MediaStreamAllocationConfig::rate_elasticity, 986 TrackRateElasticity::kCanContributeUnusedRate))); 987 EXPECT_CALL(*helper.channel_send(), StartSend()); 988 send_stream->Start(); 989 EXPECT_CALL(*helper.channel_send(), StopSend()); 990 send_stream->Stop(); 991 } 992 993 TEST(AudioSendStreamTest, OverridesPriorityBitrate) { 994 ConfigHelper helper(true, true, true); 995 helper.field_trials().Set("WebRTC-Audio-Allocation", "prio_rate:20"); 996 helper.field_trials().Set("WebRTC-Audio-PriorityBitrate", "Disabled"); 997 auto send_stream = helper.CreateAudioSendStream(); 998 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _)) 999 .WillOnce(Invoke( 1000 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) { 1001 EXPECT_EQ(config.priority_bitrate_bps, 0); 1002 })); 1003 EXPECT_CALL(*helper.channel_send(), StartSend()); 1004 send_stream->Start(); 1005 EXPECT_CALL(*helper.channel_send(), StopSend()); 1006 send_stream->Stop(); 1007 } 1008 1009 TEST(AudioSendStreamTest, UseEncoderBitrateRange) { 1010 ConfigHelper helper(true, true, true); 1011 std::pair<DataRate, DataRate> bitrate_range{DataRate::BitsPerSec(5000), 1012 DataRate::BitsPerSec(10000)}; 1013 EXPECT_CALL(helper.mock_encoder_factory(), Create) 1014 .WillOnce(WithArg<1>([&](const SdpAudioFormat& format) { 1015 auto mock_encoder = SetupAudioEncoderMock(format); 1016 EXPECT_CALL(*mock_encoder, GetBitrateRange) 1017 .WillRepeatedly(Return(bitrate_range)); 1018 return mock_encoder; 1019 })); 1020 auto send_stream = helper.CreateAudioSendStream(); 1021 EXPECT_CALL(*helper.bitrate_allocator(), AddObserver(send_stream.get(), _)) 1022 .WillOnce(Invoke( 1023 [&](BitrateAllocatorObserver*, MediaStreamAllocationConfig config) { 1024 EXPECT_EQ(config.min_bitrate_bps, bitrate_range.first.bps()); 1025 EXPECT_EQ(config.max_bitrate_bps, bitrate_range.second.bps()); 1026 })); 1027 EXPECT_CALL(*helper.channel_send(), StartSend()); 1028 send_stream->Start(); 1029 EXPECT_CALL(*helper.channel_send(), StopSend()); 1030 send_stream->Stop(); 1031 } 1032 1033 } // namespace test 1034 } // namespace webrtc