OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <array> | 11 #include <array> |
12 #include <memory> | 12 #include <memory> |
13 #include <utility> | 13 #include <utility> |
14 | 14 |
15 #include "webrtc/base/checks.h" | 15 #include "webrtc/base/checks.h" |
16 #include "webrtc/base/fakeclock.h" | 16 #include "webrtc/base/fakeclock.h" |
17 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h" | 17 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h" |
18 #include "webrtc/common_types.h" | 18 #include "webrtc/common_types.h" |
19 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_netw
ork_adaptor.h" | 19 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_netw
ork_adaptor.h" |
20 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" | 20 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" |
21 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h" | 21 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h" |
22 #include "webrtc/test/field_trial.h" | 22 #include "webrtc/test/field_trial.h" |
23 #include "webrtc/test/gmock.h" | 23 #include "webrtc/test/gmock.h" |
24 #include "webrtc/test/gtest.h" | 24 #include "webrtc/test/gtest.h" |
25 #include "webrtc/test/testsupport/fileutils.h" | 25 #include "webrtc/test/testsupport/fileutils.h" |
26 #include "webrtc/system_wrappers/include/clock.h" | |
27 | 26 |
28 namespace webrtc { | 27 namespace webrtc { |
29 using ::testing::NiceMock; | 28 using ::testing::NiceMock; |
30 using ::testing::Return; | 29 using ::testing::Return; |
31 | 30 |
32 namespace { | 31 namespace { |
33 | 32 |
34 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000}; | 33 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000}; |
35 constexpr int64_t kInitialTimeUs = 12345678; | 34 constexpr int64_t kInitialTimeUs = 12345678; |
36 | 35 |
(...skipping 12 matching lines...) Expand all Loading... |
49 AudioEncoderOpus::Config CreateConfigWithParameters( | 48 AudioEncoderOpus::Config CreateConfigWithParameters( |
50 const SdpAudioFormat::Parameters& params) { | 49 const SdpAudioFormat::Parameters& params) { |
51 SdpAudioFormat format("opus", 48000, 2, params); | 50 SdpAudioFormat format("opus", 48000, 2, params); |
52 return AudioEncoderOpus::CreateConfig(0, format); | 51 return AudioEncoderOpus::CreateConfig(0, format); |
53 } | 52 } |
54 | 53 |
55 struct AudioEncoderOpusStates { | 54 struct AudioEncoderOpusStates { |
56 std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor; | 55 std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor; |
57 MockSmoothingFilter* mock_bitrate_smoother; | 56 MockSmoothingFilter* mock_bitrate_smoother; |
58 std::unique_ptr<AudioEncoderOpus> encoder; | 57 std::unique_ptr<AudioEncoderOpus> encoder; |
59 std::unique_ptr<SimulatedClock> simulated_clock; | 58 std::unique_ptr<rtc::ScopedFakeClock> fake_clock; |
60 AudioEncoderOpus::Config config; | 59 AudioEncoderOpus::Config config; |
61 }; | 60 }; |
62 | 61 |
63 AudioEncoderOpusStates CreateCodec(size_t num_channels) { | 62 AudioEncoderOpusStates CreateCodec(size_t num_channels) { |
64 AudioEncoderOpusStates states; | 63 AudioEncoderOpusStates states; |
65 states.mock_audio_network_adaptor = | 64 states.mock_audio_network_adaptor = |
66 std::make_shared<MockAudioNetworkAdaptor*>(nullptr); | 65 std::make_shared<MockAudioNetworkAdaptor*>(nullptr); |
67 | 66 states.fake_clock.reset(new rtc::ScopedFakeClock()); |
| 67 states.fake_clock->SetTimeMicros(kInitialTimeUs); |
68 std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr( | 68 std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr( |
69 states.mock_audio_network_adaptor); | 69 states.mock_audio_network_adaptor); |
70 AudioEncoderOpus::AudioNetworkAdaptorCreator creator = [mock_ptr]( | 70 AudioEncoderOpus::AudioNetworkAdaptorCreator creator = |
71 const std::string&, RtcEventLog* event_log, const Clock*) { | 71 [mock_ptr](const std::string&, RtcEventLog* event_log) { |
72 std::unique_ptr<MockAudioNetworkAdaptor> adaptor( | 72 std::unique_ptr<MockAudioNetworkAdaptor> adaptor( |
73 new NiceMock<MockAudioNetworkAdaptor>()); | 73 new NiceMock<MockAudioNetworkAdaptor>()); |
74 EXPECT_CALL(*adaptor, Die()); | 74 EXPECT_CALL(*adaptor, Die()); |
75 if (auto sp = mock_ptr.lock()) { | 75 if (auto sp = mock_ptr.lock()) { |
76 *sp = adaptor.get(); | 76 *sp = adaptor.get(); |
77 } else { | 77 } else { |
78 RTC_NOTREACHED(); | 78 RTC_NOTREACHED(); |
79 } | 79 } |
80 return adaptor; | 80 return adaptor; |
81 }; | 81 }; |
82 | 82 |
83 CodecInst codec_inst = kDefaultOpusSettings; | 83 CodecInst codec_inst = kDefaultOpusSettings; |
84 codec_inst.channels = num_channels; | 84 codec_inst.channels = num_channels; |
85 states.config = CreateConfig(codec_inst); | 85 states.config = CreateConfig(codec_inst); |
86 std::unique_ptr<MockSmoothingFilter> bitrate_smoother( | 86 std::unique_ptr<MockSmoothingFilter> bitrate_smoother( |
87 new MockSmoothingFilter()); | 87 new MockSmoothingFilter()); |
88 states.mock_bitrate_smoother = bitrate_smoother.get(); | 88 states.mock_bitrate_smoother = bitrate_smoother.get(); |
89 states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs)); | |
90 states.config.clock = states.simulated_clock.get(); | |
91 | 89 |
92 states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator), | 90 states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator), |
93 std::move(bitrate_smoother))); | 91 std::move(bitrate_smoother))); |
94 return states; | 92 return states; |
95 } | 93 } |
96 | 94 |
97 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() { | 95 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() { |
98 constexpr int kBitrate = 40000; | 96 constexpr int kBitrate = 40000; |
99 constexpr int kFrameLength = 60; | 97 constexpr int kFrameLength = 60; |
100 constexpr bool kEnableFec = true; | 98 constexpr bool kEnableFec = true; |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
237 // of them. | 235 // of them. |
238 void TestSetPacketLossRate(AudioEncoderOpusStates* states, | 236 void TestSetPacketLossRate(AudioEncoderOpusStates* states, |
239 const std::vector<float>& losses, | 237 const std::vector<float>& losses, |
240 float expected_return) { | 238 float expected_return) { |
241 // |kSampleIntervalMs| is chosen to ease the calculation since | 239 // |kSampleIntervalMs| is chosen to ease the calculation since |
242 // 0.9999 ^ 184198 = 1e-8. Which minimizes the effect of | 240 // 0.9999 ^ 184198 = 1e-8. Which minimizes the effect of |
243 // PacketLossFractionSmoother used in AudioEncoderOpus. | 241 // PacketLossFractionSmoother used in AudioEncoderOpus. |
244 constexpr int64_t kSampleIntervalMs = 184198; | 242 constexpr int64_t kSampleIntervalMs = 184198; |
245 for (float loss : losses) { | 243 for (float loss : losses) { |
246 states->encoder->OnReceivedUplinkPacketLossFraction(loss); | 244 states->encoder->OnReceivedUplinkPacketLossFraction(loss); |
247 states->simulated_clock->AdvanceTimeMilliseconds(kSampleIntervalMs); | 245 states->fake_clock->AdvanceTime( |
| 246 rtc::TimeDelta::FromMilliseconds(kSampleIntervalMs)); |
248 EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate()); | 247 EXPECT_FLOAT_EQ(expected_return, states->encoder->packet_loss_rate()); |
249 } | 248 } |
250 } | 249 } |
251 | 250 |
252 } // namespace | 251 } // namespace |
253 | 252 |
254 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) { | 253 TEST(AudioEncoderOpusTest, PacketLossRateOptimized) { |
255 auto states = CreateCodec(1); | 254 auto states = CreateCodec(1); |
256 auto I = [](float a, float b) { return IntervalSteps(a, b, 10); }; | 255 auto I = [](float a, float b) { return IntervalSteps(a, b, 10); }; |
257 constexpr float eps = 1e-8f; | 256 constexpr float eps = 1e-8f; |
(...skipping 26 matching lines...) Expand all Loading... |
284 states.encoder->SetReceiverFrameLengthRange(0, 12345); | 283 states.encoder->SetReceiverFrameLengthRange(0, 12345); |
285 states.encoder->SetReceiverFrameLengthRange(21, 60); | 284 states.encoder->SetReceiverFrameLengthRange(21, 60); |
286 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60)); | 285 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60)); |
287 states.encoder->SetReceiverFrameLengthRange(20, 59); | 286 states.encoder->SetReceiverFrameLengthRange(20, 59); |
288 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20)); | 287 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20)); |
289 } | 288 } |
290 | 289 |
291 TEST(AudioEncoderOpusTest, | 290 TEST(AudioEncoderOpusTest, |
292 InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) { | 291 InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) { |
293 auto states = CreateCodec(2); | 292 auto states = CreateCodec(2); |
294 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 293 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
295 | 294 |
296 auto config = CreateEncoderRuntimeConfig(); | 295 auto config = CreateEncoderRuntimeConfig(); |
297 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 296 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
298 .WillOnce(Return(config)); | 297 .WillOnce(Return(config)); |
299 | 298 |
300 // Since using mock audio network adaptor, any packet loss fraction is fine. | 299 // Since using mock audio network adaptor, any packet loss fraction is fine. |
301 constexpr float kUplinkPacketLoss = 0.1f; | 300 constexpr float kUplinkPacketLoss = 0.1f; |
302 EXPECT_CALL(**states.mock_audio_network_adaptor, | 301 EXPECT_CALL(**states.mock_audio_network_adaptor, |
303 SetUplinkPacketLossFraction(kUplinkPacketLoss)); | 302 SetUplinkPacketLossFraction(kUplinkPacketLoss)); |
304 states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss); | 303 states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss); |
305 | 304 |
306 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 305 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
307 } | 306 } |
308 | 307 |
309 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) { | 308 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) { |
310 auto states = CreateCodec(2); | 309 auto states = CreateCodec(2); |
311 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 310 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
312 | 311 |
313 auto config = CreateEncoderRuntimeConfig(); | 312 auto config = CreateEncoderRuntimeConfig(); |
314 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 313 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
315 .WillOnce(Return(config)); | 314 .WillOnce(Return(config)); |
316 | 315 |
317 // Since using mock audio network adaptor, any target audio bitrate is fine. | 316 // Since using mock audio network adaptor, any target audio bitrate is fine. |
318 constexpr int kTargetAudioBitrate = 30000; | 317 constexpr int kTargetAudioBitrate = 30000; |
319 constexpr int64_t kProbingIntervalMs = 3000; | 318 constexpr int64_t kProbingIntervalMs = 3000; |
320 EXPECT_CALL(**states.mock_audio_network_adaptor, | 319 EXPECT_CALL(**states.mock_audio_network_adaptor, |
321 SetTargetAudioBitrate(kTargetAudioBitrate)); | 320 SetTargetAudioBitrate(kTargetAudioBitrate)); |
322 EXPECT_CALL(*states.mock_bitrate_smoother, | 321 EXPECT_CALL(*states.mock_bitrate_smoother, |
323 SetTimeConstantMs(kProbingIntervalMs * 4)); | 322 SetTimeConstantMs(kProbingIntervalMs * 4)); |
324 EXPECT_CALL(*states.mock_bitrate_smoother, AddSample(kTargetAudioBitrate)); | 323 EXPECT_CALL(*states.mock_bitrate_smoother, AddSample(kTargetAudioBitrate)); |
325 states.encoder->OnReceivedUplinkBandwidth( | 324 states.encoder->OnReceivedUplinkBandwidth( |
326 kTargetAudioBitrate, rtc::Optional<int64_t>(kProbingIntervalMs)); | 325 kTargetAudioBitrate, rtc::Optional<int64_t>(kProbingIntervalMs)); |
327 | 326 |
328 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 327 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
329 } | 328 } |
330 | 329 |
331 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) { | 330 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) { |
332 auto states = CreateCodec(2); | 331 auto states = CreateCodec(2); |
333 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 332 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
334 | 333 |
335 auto config = CreateEncoderRuntimeConfig(); | 334 auto config = CreateEncoderRuntimeConfig(); |
336 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 335 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
337 .WillOnce(Return(config)); | 336 .WillOnce(Return(config)); |
338 | 337 |
339 // Since using mock audio network adaptor, any rtt is fine. | 338 // Since using mock audio network adaptor, any rtt is fine. |
340 constexpr int kRtt = 30; | 339 constexpr int kRtt = 30; |
341 EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt)); | 340 EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt)); |
342 states.encoder->OnReceivedRtt(kRtt); | 341 states.encoder->OnReceivedRtt(kRtt); |
343 | 342 |
344 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 343 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
345 } | 344 } |
346 | 345 |
347 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) { | 346 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) { |
348 auto states = CreateCodec(2); | 347 auto states = CreateCodec(2); |
349 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 348 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
350 | 349 |
351 auto config = CreateEncoderRuntimeConfig(); | 350 auto config = CreateEncoderRuntimeConfig(); |
352 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 351 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
353 .WillOnce(Return(config)); | 352 .WillOnce(Return(config)); |
354 | 353 |
355 // Since using mock audio network adaptor, any overhead is fine. | 354 // Since using mock audio network adaptor, any overhead is fine. |
356 constexpr size_t kOverhead = 64; | 355 constexpr size_t kOverhead = 64; |
357 EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead)); | 356 EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead)); |
358 states.encoder->OnReceivedOverhead(kOverhead); | 357 states.encoder->OnReceivedOverhead(kOverhead); |
359 | 358 |
360 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 359 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
361 } | 360 } |
362 | 361 |
363 TEST(AudioEncoderOpusTest, | 362 TEST(AudioEncoderOpusTest, |
364 PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) { | 363 PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) { |
365 auto states = CreateCodec(2); | 364 auto states = CreateCodec(2); |
366 | 365 |
367 // The values are carefully chosen so that if no smoothing is made, the test | 366 // The values are carefully chosen so that if no smoothing is made, the test |
368 // will fail. | 367 // will fail. |
369 constexpr float kPacketLossFraction_1 = 0.02f; | 368 constexpr float kPacketLossFraction_1 = 0.02f; |
370 constexpr float kPacketLossFraction_2 = 0.198f; | 369 constexpr float kPacketLossFraction_2 = 0.198f; |
371 // |kSecondSampleTimeMs| is chosen to ease the calculation since | 370 // |kSecondSampleTimeMs| is chosen to ease the calculation since |
372 // 0.9999 ^ 6931 = 0.5. | 371 // 0.9999 ^ 6931 = 0.5. |
373 constexpr int64_t kSecondSampleTimeMs = 6931; | 372 constexpr int64_t kSecondSampleTimeMs = 6931; |
374 | 373 |
375 // First time, no filtering. | 374 // First time, no filtering. |
376 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); | 375 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); |
377 EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); | 376 EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); |
378 | 377 |
379 states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs); | 378 states.fake_clock->AdvanceTime( |
| 379 rtc::TimeDelta::FromMilliseconds(kSecondSampleTimeMs)); |
380 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); | 380 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); |
381 | 381 |
382 // Now the output of packet loss fraction smoother should be | 382 // Now the output of packet loss fraction smoother should be |
383 // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized | 383 // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized |
384 // packet loss rate to increase to 0.05. If no smoothing has been made, the | 384 // packet loss rate to increase to 0.05. If no smoothing has been made, the |
385 // optimized packet loss rate should have been increase to 0.1. | 385 // optimized packet loss rate should have been increase to 0.1. |
386 EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate()); | 386 EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate()); |
387 } | 387 } |
388 | 388 |
389 TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) { | 389 TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) { |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
468 config.bitrate_bps = rtc::Optional<int>(12500); | 468 config.bitrate_bps = rtc::Optional<int>(12500); |
469 EXPECT_EQ(rtc::Optional<int>(), config.GetNewComplexity()); | 469 EXPECT_EQ(rtc::Optional<int>(), config.GetNewComplexity()); |
470 | 470 |
471 // Bitrate above hysteresis window. Expect lower complexity. | 471 // Bitrate above hysteresis window. Expect lower complexity. |
472 config.bitrate_bps = rtc::Optional<int>(14001); | 472 config.bitrate_bps = rtc::Optional<int>(14001); |
473 EXPECT_EQ(rtc::Optional<int>(6), config.GetNewComplexity()); | 473 EXPECT_EQ(rtc::Optional<int>(6), config.GetNewComplexity()); |
474 } | 474 } |
475 | 475 |
476 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) { | 476 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) { |
477 auto states = CreateCodec(2); | 477 auto states = CreateCodec(2); |
478 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 478 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
479 | 479 |
480 auto config = CreateEncoderRuntimeConfig(); | 480 auto config = CreateEncoderRuntimeConfig(); |
481 AudioEncoderRuntimeConfig empty_config; | 481 AudioEncoderRuntimeConfig empty_config; |
482 | 482 |
483 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 483 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
484 .WillOnce(Return(config)) | 484 .WillOnce(Return(config)) |
485 .WillOnce(Return(empty_config)); | 485 .WillOnce(Return(empty_config)); |
486 | 486 |
487 constexpr size_t kOverhead = 64; | 487 constexpr size_t kOverhead = 64; |
488 EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead)) | 488 EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead)) |
489 .Times(2); | 489 .Times(2); |
490 states.encoder->OnReceivedOverhead(kOverhead); | 490 states.encoder->OnReceivedOverhead(kOverhead); |
491 states.encoder->OnReceivedOverhead(kOverhead); | 491 states.encoder->OnReceivedOverhead(kOverhead); |
492 | 492 |
493 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 493 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
494 } | 494 } |
495 | 495 |
496 TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) { | 496 TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) { |
497 rtc::ScopedFakeClock fake_clock; | |
498 auto states = CreateCodec(2); | 497 auto states = CreateCodec(2); |
499 states.encoder->EnableAudioNetworkAdaptor("", nullptr, nullptr); | 498 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
500 std::array<int16_t, 480 * 2> audio; | 499 std::array<int16_t, 480 * 2> audio; |
501 audio.fill(0); | 500 audio.fill(0); |
502 rtc::Buffer encoded; | 501 rtc::Buffer encoded; |
503 EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) | 502 EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) |
504 .WillOnce(Return(rtc::Optional<float>(50000))); | 503 .WillOnce(Return(rtc::Optional<float>(50000))); |
505 EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000)); | 504 EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000)); |
506 states.encoder->Encode( | 505 states.encoder->Encode( |
507 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); | 506 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); |
508 | 507 |
509 // Repeat update uplink bandwidth tests. | 508 // Repeat update uplink bandwidth tests. |
510 for (int i = 0; i < 5; i++) { | 509 for (int i = 0; i < 5; i++) { |
511 // Don't update till it is time to update again. | 510 // Don't update till it is time to update again. |
512 fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds( | 511 states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds( |
513 states.config.uplink_bandwidth_update_interval_ms - 1)); | 512 states.config.uplink_bandwidth_update_interval_ms - 1)); |
514 states.encoder->Encode( | 513 states.encoder->Encode( |
515 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); | 514 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); |
516 | 515 |
517 // Update when it is time to update. | 516 // Update when it is time to update. |
518 EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) | 517 EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) |
519 .WillOnce(Return(rtc::Optional<float>(40000))); | 518 .WillOnce(Return(rtc::Optional<float>(40000))); |
520 EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000)); | 519 EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000)); |
521 fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1)); | 520 states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(1)); |
522 states.encoder->Encode( | 521 states.encoder->Encode( |
523 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); | 522 0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded); |
524 } | 523 } |
525 } | 524 } |
526 | 525 |
527 TEST(AudioEncoderOpusTest, EncodeAtMinBitrate) { | 526 TEST(AudioEncoderOpusTest, EncodeAtMinBitrate) { |
528 auto states = CreateCodec(1); | 527 auto states = CreateCodec(1); |
529 constexpr int kNumPacketsToEncode = 2; | 528 constexpr int kNumPacketsToEncode = 2; |
530 auto audio_frames = | 529 auto audio_frames = |
531 Create10msAudioBlocks(states.encoder, kNumPacketsToEncode * 20); | 530 Create10msAudioBlocks(states.encoder, kNumPacketsToEncode * 20); |
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
741 EXPECT_EQ(24001, config.max_playback_rate_hz); | 740 EXPECT_EQ(24001, config.max_playback_rate_hz); |
742 EXPECT_EQ(32000, config.bitrate_bps); | 741 EXPECT_EQ(32000, config.bitrate_bps); |
743 | 742 |
744 config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}, | 743 config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}, |
745 {"stereo", "1"}}); | 744 {"stereo", "1"}}); |
746 EXPECT_EQ(24001, config.max_playback_rate_hz); | 745 EXPECT_EQ(24001, config.max_playback_rate_hz); |
747 EXPECT_EQ(64000, config.bitrate_bps); | 746 EXPECT_EQ(64000, config.bitrate_bps); |
748 } | 747 } |
749 | 748 |
750 } // namespace webrtc | 749 } // namespace webrtc |
OLD | NEW |