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 <memory> | 11 #include <memory> |
12 | 12 |
13 #include "webrtc/base/checks.h" | 13 #include "webrtc/base/checks.h" |
14 #include "webrtc/common_types.h" | 14 #include "webrtc/common_types.h" |
15 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_netw
ork_adaptor.h" | 15 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_netw
ork_adaptor.h" |
16 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" | 16 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h" |
| 17 #include "webrtc/test/field_trial.h" |
17 #include "webrtc/test/gmock.h" | 18 #include "webrtc/test/gmock.h" |
18 #include "webrtc/test/gtest.h" | 19 #include "webrtc/test/gtest.h" |
19 #include "webrtc/system_wrappers/include/clock.h" | 20 #include "webrtc/system_wrappers/include/clock.h" |
20 | 21 |
21 namespace webrtc { | 22 namespace webrtc { |
22 using ::testing::NiceMock; | 23 using ::testing::NiceMock; |
23 using ::testing::Return; | 24 using ::testing::Return; |
24 | 25 |
25 namespace { | 26 namespace { |
26 | 27 |
(...skipping 215 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
242 ElementsAre(states.encoder->next_frame_length_ms())); | 243 ElementsAre(states.encoder->next_frame_length_ms())); |
243 states.encoder->SetReceiverFrameLengthRange(0, 12345); | 244 states.encoder->SetReceiverFrameLengthRange(0, 12345); |
244 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), | 245 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), |
245 ElementsAre(20, 60)); | 246 ElementsAre(20, 60)); |
246 states.encoder->SetReceiverFrameLengthRange(21, 60); | 247 states.encoder->SetReceiverFrameLengthRange(21, 60); |
247 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60)); | 248 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60)); |
248 states.encoder->SetReceiverFrameLengthRange(20, 59); | 249 states.encoder->SetReceiverFrameLengthRange(20, 59); |
249 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20)); | 250 EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20)); |
250 } | 251 } |
251 | 252 |
252 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetUplinkBandwidth) { | 253 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) { |
253 auto states = CreateCodec(2); | 254 auto states = CreateCodec(2); |
254 states.encoder->EnableAudioNetworkAdaptor("", nullptr); | 255 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
255 | 256 |
256 auto config = CreateEncoderRuntimeConfig(); | 257 auto config = CreateEncoderRuntimeConfig(); |
257 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 258 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
258 .WillOnce(Return(config)); | 259 .WillOnce(Return(config)); |
259 | 260 |
260 // Since using mock audio network adaptor, any bandwidth value is fine. | 261 // Since using mock audio network adaptor, any bandwidth value is fine. |
261 constexpr int kUplinkBandwidth = 50000; | 262 constexpr int kUplinkBandwidth = 50000; |
262 EXPECT_CALL(**states.mock_audio_network_adaptor, | 263 EXPECT_CALL(**states.mock_audio_network_adaptor, |
263 SetUplinkBandwidth(kUplinkBandwidth)); | 264 SetUplinkBandwidth(kUplinkBandwidth)); |
264 states.encoder->OnReceivedUplinkBandwidth(kUplinkBandwidth); | 265 states.encoder->OnReceivedUplinkBandwidth(kUplinkBandwidth); |
265 | 266 |
266 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 267 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
267 } | 268 } |
268 | 269 |
269 TEST(AudioEncoderOpusTest, | 270 TEST(AudioEncoderOpusTest, |
270 InvokeAudioNetworkAdaptorOnSetUplinkPacketLossFraction) { | 271 InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) { |
271 auto states = CreateCodec(2); | 272 auto states = CreateCodec(2); |
272 states.encoder->EnableAudioNetworkAdaptor("", nullptr); | 273 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
273 | 274 |
274 auto config = CreateEncoderRuntimeConfig(); | 275 auto config = CreateEncoderRuntimeConfig(); |
275 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 276 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
276 .WillOnce(Return(config)); | 277 .WillOnce(Return(config)); |
277 | 278 |
278 // Since using mock audio network adaptor, any packet loss fraction is fine. | 279 // Since using mock audio network adaptor, any packet loss fraction is fine. |
279 constexpr float kUplinkPacketLoss = 0.1f; | 280 constexpr float kUplinkPacketLoss = 0.1f; |
280 EXPECT_CALL(**states.mock_audio_network_adaptor, | 281 EXPECT_CALL(**states.mock_audio_network_adaptor, |
281 SetUplinkPacketLossFraction(kUplinkPacketLoss)); | 282 SetUplinkPacketLossFraction(kUplinkPacketLoss)); |
282 states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss); | 283 states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss); |
283 | 284 |
284 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 285 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
285 } | 286 } |
286 | 287 |
287 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetTargetAudioBitrate) { | 288 TEST(AudioEncoderOpusTest, |
| 289 InvokeAudioNetworkAdaptorOnReceivedTargetAudioBitrate) { |
288 auto states = CreateCodec(2); | 290 auto states = CreateCodec(2); |
289 states.encoder->EnableAudioNetworkAdaptor("", nullptr); | 291 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
290 | 292 |
291 auto config = CreateEncoderRuntimeConfig(); | 293 auto config = CreateEncoderRuntimeConfig(); |
292 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 294 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
293 .WillOnce(Return(config)); | 295 .WillOnce(Return(config)); |
294 | 296 |
295 // Since using mock audio network adaptor, any target audio bitrate is fine. | 297 // Since using mock audio network adaptor, any target audio bitrate is fine. |
296 constexpr int kTargetAudioBitrate = 30000; | 298 constexpr int kTargetAudioBitrate = 30000; |
297 EXPECT_CALL(**states.mock_audio_network_adaptor, | 299 EXPECT_CALL(**states.mock_audio_network_adaptor, |
298 SetTargetAudioBitrate(kTargetAudioBitrate)); | 300 SetTargetAudioBitrate(kTargetAudioBitrate)); |
299 states.encoder->OnReceivedTargetAudioBitrate(kTargetAudioBitrate); | 301 states.encoder->OnReceivedTargetAudioBitrate(kTargetAudioBitrate); |
300 | 302 |
301 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 303 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
302 } | 304 } |
303 | 305 |
304 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetRtt) { | 306 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) { |
305 auto states = CreateCodec(2); | 307 auto states = CreateCodec(2); |
306 states.encoder->EnableAudioNetworkAdaptor("", nullptr); | 308 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
307 | 309 |
308 auto config = CreateEncoderRuntimeConfig(); | 310 auto config = CreateEncoderRuntimeConfig(); |
309 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 311 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
310 .WillOnce(Return(config)); | 312 .WillOnce(Return(config)); |
311 | 313 |
312 // Since using mock audio network adaptor, any rtt is fine. | 314 // Since using mock audio network adaptor, any rtt is fine. |
313 constexpr int kRtt = 30; | 315 constexpr int kRtt = 30; |
314 EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt)); | 316 EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt)); |
315 states.encoder->OnReceivedRtt(kRtt); | 317 states.encoder->OnReceivedRtt(kRtt); |
316 | 318 |
317 CheckEncoderRuntimeConfig(states.encoder.get(), config); | 319 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
318 } | 320 } |
319 | 321 |
| 322 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) { |
| 323 auto states = CreateCodec(2); |
| 324 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
| 325 |
| 326 auto config = CreateEncoderRuntimeConfig(); |
| 327 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
| 328 .WillOnce(Return(config)); |
| 329 |
| 330 // Since using mock audio network adaptor, any overhead is fine. |
| 331 constexpr size_t kOverhead = 64; |
| 332 EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead)); |
| 333 states.encoder->OnReceivedOverhead(kOverhead); |
| 334 |
| 335 CheckEncoderRuntimeConfig(states.encoder.get(), config); |
| 336 } |
| 337 |
320 TEST(AudioEncoderOpusTest, | 338 TEST(AudioEncoderOpusTest, |
321 PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) { | 339 PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) { |
322 auto states = CreateCodec(2); | 340 auto states = CreateCodec(2); |
323 | 341 |
324 // The values are carefully chosen so that if no smoothing is made, the test | 342 // The values are carefully chosen so that if no smoothing is made, the test |
325 // will fail. | 343 // will fail. |
326 constexpr float kPacketLossFraction_1 = 0.02f; | 344 constexpr float kPacketLossFraction_1 = 0.02f; |
327 constexpr float kPacketLossFraction_2 = 0.198f; | 345 constexpr float kPacketLossFraction_2 = 0.198f; |
328 // |kSecondSampleTimeMs| is chosen to ease the calculation since | 346 // |kSecondSampleTimeMs| is chosen to ease the calculation since |
329 // 0.9999 ^ 6931 = 0.5. | 347 // 0.9999 ^ 6931 = 0.5. |
330 constexpr int64_t kSecondSampleTimeMs = 6931; | 348 constexpr int64_t kSecondSampleTimeMs = 6931; |
331 | 349 |
332 // First time, no filtering. | 350 // First time, no filtering. |
333 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); | 351 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1); |
334 EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); | 352 EXPECT_FLOAT_EQ(0.01f, states.encoder->packet_loss_rate()); |
335 | 353 |
336 states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs); | 354 states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs); |
337 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); | 355 states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2); |
338 | 356 |
339 // Now the output of packet loss fraction smoother should be | 357 // Now the output of packet loss fraction smoother should be |
340 // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized | 358 // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized |
341 // packet loss rate to increase to 0.05. If no smoothing has been made, the | 359 // packet loss rate to increase to 0.05. If no smoothing has been made, the |
342 // optimized packet loss rate should have been increase to 0.1. | 360 // optimized packet loss rate should have been increase to 0.1. |
343 EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate()); | 361 EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate()); |
344 } | 362 } |
345 | 363 |
| 364 TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) { |
| 365 test::ScopedFieldTrials override_field_trials( |
| 366 "WebRTC-SendSideBwe-WithOverhead/Enabled/"); |
| 367 |
| 368 auto states = CreateCodec(2); |
| 369 |
| 370 states.encoder->OnReceivedTargetAudioBitrate(kDefaultOpusSettings.rate * 2); |
| 371 |
| 372 // Since |OnReceivedOverhead| has not been called, the codec bitrate should |
| 373 // not change. |
| 374 EXPECT_EQ(kDefaultOpusSettings.rate, states.encoder->GetTargetBitrate()); |
| 375 } |
| 376 |
| 377 TEST(AudioEncoderOpusTest, OverheadRemovedFromTargetAudioBitrate) { |
| 378 test::ScopedFieldTrials override_field_trials( |
| 379 "WebRTC-SendSideBwe-WithOverhead/Enabled/"); |
| 380 |
| 381 auto states = CreateCodec(2); |
| 382 |
| 383 constexpr size_t kOverheadBytesPerPacket = 64; |
| 384 states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket); |
| 385 |
| 386 constexpr int kTargetBitrateBps = 40000; |
| 387 states.encoder->OnReceivedTargetAudioBitrate(kTargetBitrateBps); |
| 388 |
| 389 int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize); |
| 390 EXPECT_EQ(kTargetBitrateBps - |
| 391 8 * static_cast<int>(kOverheadBytesPerPacket) * packet_rate, |
| 392 states.encoder->GetTargetBitrate()); |
| 393 } |
| 394 |
| 395 TEST(AudioEncoderOpusTest, BitrateBounded) { |
| 396 test::ScopedFieldTrials override_field_trials( |
| 397 "WebRTC-SendSideBwe-WithOverhead/Enabled/"); |
| 398 |
| 399 constexpr int kMinBitrateBps = 500; |
| 400 constexpr int kMaxBitrateBps = 512000; |
| 401 |
| 402 auto states = CreateCodec(2); |
| 403 |
| 404 constexpr size_t kOverheadBytesPerPacket = 64; |
| 405 states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket); |
| 406 |
| 407 int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize); |
| 408 |
| 409 // Set a target rate that is smaller than |kMinBitrateBps| when overhead is |
| 410 // subtracted. The eventual codec rate should be bounded by |kMinBitrateBps|. |
| 411 int target_bitrate = |
| 412 kOverheadBytesPerPacket * 8 * packet_rate + kMinBitrateBps - 1; |
| 413 states.encoder->OnReceivedTargetAudioBitrate(target_bitrate); |
| 414 EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); |
| 415 |
| 416 // Set a target rate that is greater than |kMaxBitrateBps| when overhead is |
| 417 // subtracted. The eventual codec rate should be bounded by |kMaxBitrateBps|. |
| 418 target_bitrate = |
| 419 kOverheadBytesPerPacket * 8 * packet_rate + kMaxBitrateBps + 1; |
| 420 states.encoder->OnReceivedTargetAudioBitrate(target_bitrate); |
| 421 EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); |
| 422 } |
| 423 |
346 } // namespace webrtc | 424 } // namespace webrtc |
OLD | NEW |