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 |
(...skipping 15 matching lines...) Expand all Loading... |
26 | 26 |
27 namespace webrtc { | 27 namespace webrtc { |
28 using ::testing::NiceMock; | 28 using ::testing::NiceMock; |
29 using ::testing::Return; | 29 using ::testing::Return; |
30 | 30 |
31 namespace { | 31 namespace { |
32 | 32 |
33 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000}; | 33 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000}; |
34 constexpr int64_t kInitialTimeUs = 12345678; | 34 constexpr int64_t kInitialTimeUs = 12345678; |
35 | 35 |
36 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) { | 36 AudioEncoderOpusConfig CreateConfig(const CodecInst& codec_inst) { |
37 AudioEncoderOpus::Config config; | 37 AudioEncoderOpusConfig config; |
38 config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48); | 38 config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48); |
39 config.num_channels = codec_inst.channels; | 39 config.num_channels = codec_inst.channels; |
40 config.bitrate_bps = rtc::Optional<int>(codec_inst.rate); | 40 config.bitrate_bps = rtc::Optional<int>(codec_inst.rate); |
41 config.payload_type = codec_inst.pltype; | 41 config.application = config.num_channels == 1 |
42 config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip | 42 ? AudioEncoderOpusConfig::ApplicationMode::kVoip |
43 : AudioEncoderOpus::kAudio; | 43 : AudioEncoderOpusConfig::ApplicationMode::kAudio; |
44 config.supported_frame_lengths_ms.push_back(config.frame_size_ms); | 44 config.supported_frame_lengths_ms.push_back(config.frame_size_ms); |
45 return config; | 45 return config; |
46 } | 46 } |
47 | 47 |
48 AudioEncoderOpus::Config CreateConfigWithParameters( | 48 AudioEncoderOpusConfig CreateConfigWithParameters( |
49 const SdpAudioFormat::Parameters& params) { | 49 const SdpAudioFormat::Parameters& params) { |
50 SdpAudioFormat format("opus", 48000, 2, params); | 50 const SdpAudioFormat format("opus", 48000, 2, params); |
51 return AudioEncoderOpus::CreateConfig(0, format); | 51 return *AudioEncoderOpus::SdpToConfig(format); |
52 } | 52 } |
53 | 53 |
54 struct AudioEncoderOpusStates { | 54 struct AudioEncoderOpusStates { |
55 std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor; | 55 std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor; |
56 MockSmoothingFilter* mock_bitrate_smoother; | 56 MockSmoothingFilter* mock_bitrate_smoother; |
57 std::unique_ptr<AudioEncoderOpus> encoder; | 57 std::unique_ptr<AudioEncoderOpus> encoder; |
58 std::unique_ptr<rtc::ScopedFakeClock> fake_clock; | 58 std::unique_ptr<rtc::ScopedFakeClock> fake_clock; |
59 AudioEncoderOpus::Config config; | 59 AudioEncoderOpusConfig config; |
60 }; | 60 }; |
61 | 61 |
62 AudioEncoderOpusStates CreateCodec(size_t num_channels) { | 62 AudioEncoderOpusStates CreateCodec(size_t num_channels) { |
63 AudioEncoderOpusStates states; | 63 AudioEncoderOpusStates states; |
64 states.mock_audio_network_adaptor = | 64 states.mock_audio_network_adaptor = |
65 std::make_shared<MockAudioNetworkAdaptor*>(nullptr); | 65 std::make_shared<MockAudioNetworkAdaptor*>(nullptr); |
66 states.fake_clock.reset(new rtc::ScopedFakeClock()); | 66 states.fake_clock.reset(new rtc::ScopedFakeClock()); |
67 states.fake_clock->SetTimeMicros(kInitialTimeUs); | 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); |
(...skipping 10 matching lines...) Expand all Loading... |
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 | 89 |
90 states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator), | 90 states.encoder.reset(new AudioEncoderOpus(states.config, codec_inst.pltype, |
| 91 std::move(creator), |
91 std::move(bitrate_smoother))); | 92 std::move(bitrate_smoother))); |
92 return states; | 93 return states; |
93 } | 94 } |
94 | 95 |
95 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() { | 96 AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() { |
96 constexpr int kBitrate = 40000; | 97 constexpr int kBitrate = 40000; |
97 constexpr int kFrameLength = 60; | 98 constexpr int kFrameLength = 60; |
98 constexpr bool kEnableFec = true; | 99 constexpr bool kEnableFec = true; |
99 constexpr bool kEnableDtx = false; | 100 constexpr bool kEnableDtx = false; |
100 constexpr size_t kNumChannels = 1; | 101 constexpr size_t kNumChannels = 1; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 encoder->num_channels_to_encode(), | 136 encoder->num_channels_to_encode(), |
136 10 * audio_samples_per_ms * encoder->num_channels_to_encode())) | 137 10 * audio_samples_per_ms * encoder->num_channels_to_encode())) |
137 return nullptr; | 138 return nullptr; |
138 return speech_data; | 139 return speech_data; |
139 } | 140 } |
140 | 141 |
141 } // namespace | 142 } // namespace |
142 | 143 |
143 TEST(AudioEncoderOpusTest, DefaultApplicationModeMono) { | 144 TEST(AudioEncoderOpusTest, DefaultApplicationModeMono) { |
144 auto states = CreateCodec(1); | 145 auto states = CreateCodec(1); |
145 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); | 146 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip, |
| 147 states.encoder->application()); |
146 } | 148 } |
147 | 149 |
148 TEST(AudioEncoderOpusTest, DefaultApplicationModeStereo) { | 150 TEST(AudioEncoderOpusTest, DefaultApplicationModeStereo) { |
149 auto states = CreateCodec(2); | 151 auto states = CreateCodec(2); |
150 EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application()); | 152 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kAudio, |
| 153 states.encoder->application()); |
151 } | 154 } |
152 | 155 |
153 TEST(AudioEncoderOpusTest, ChangeApplicationMode) { | 156 TEST(AudioEncoderOpusTest, ChangeApplicationMode) { |
154 auto states = CreateCodec(2); | 157 auto states = CreateCodec(2); |
155 EXPECT_TRUE( | 158 EXPECT_TRUE( |
156 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); | 159 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); |
157 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); | 160 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip, |
| 161 states.encoder->application()); |
158 } | 162 } |
159 | 163 |
160 TEST(AudioEncoderOpusTest, ResetWontChangeApplicationMode) { | 164 TEST(AudioEncoderOpusTest, ResetWontChangeApplicationMode) { |
161 auto states = CreateCodec(2); | 165 auto states = CreateCodec(2); |
162 | 166 |
163 // Trigger a reset. | 167 // Trigger a reset. |
164 states.encoder->Reset(); | 168 states.encoder->Reset(); |
165 // Verify that the mode is still kAudio. | 169 // Verify that the mode is still kAudio. |
166 EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application()); | 170 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kAudio, |
| 171 states.encoder->application()); |
167 | 172 |
168 // Now change to kVoip. | 173 // Now change to kVoip. |
169 EXPECT_TRUE( | 174 EXPECT_TRUE( |
170 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); | 175 states.encoder->SetApplication(AudioEncoder::Application::kSpeech)); |
171 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); | 176 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip, |
| 177 states.encoder->application()); |
172 | 178 |
173 // Trigger a reset again. | 179 // Trigger a reset again. |
174 states.encoder->Reset(); | 180 states.encoder->Reset(); |
175 // Verify that the mode is still kVoip. | 181 // Verify that the mode is still kVoip. |
176 EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application()); | 182 EXPECT_EQ(AudioEncoderOpusConfig::ApplicationMode::kVoip, |
| 183 states.encoder->application()); |
177 } | 184 } |
178 | 185 |
179 TEST(AudioEncoderOpusTest, ToggleDtx) { | 186 TEST(AudioEncoderOpusTest, ToggleDtx) { |
180 auto states = CreateCodec(2); | 187 auto states = CreateCodec(2); |
181 // Enable DTX | 188 // Enable DTX |
182 EXPECT_TRUE(states.encoder->SetDtx(true)); | 189 EXPECT_TRUE(states.encoder->SetDtx(true)); |
183 EXPECT_TRUE(states.encoder->GetDtx()); | 190 EXPECT_TRUE(states.encoder->GetDtx()); |
184 // Turn off DTX. | 191 // Turn off DTX. |
185 EXPECT_TRUE(states.encoder->SetDtx(false)); | 192 EXPECT_TRUE(states.encoder->SetDtx(false)); |
186 EXPECT_FALSE(states.encoder->GetDtx()); | 193 EXPECT_FALSE(states.encoder->GetDtx()); |
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
445 // subtracted. The eventual codec rate should be bounded by |kMaxBitrateBps|. | 452 // subtracted. The eventual codec rate should be bounded by |kMaxBitrateBps|. |
446 target_bitrate = | 453 target_bitrate = |
447 kOverheadBytesPerPacket * 8 * packet_rate + kMaxBitrateBps + 1; | 454 kOverheadBytesPerPacket * 8 * packet_rate + kMaxBitrateBps + 1; |
448 states.encoder->OnReceivedUplinkBandwidth(target_bitrate, | 455 states.encoder->OnReceivedUplinkBandwidth(target_bitrate, |
449 rtc::Optional<int64_t>()); | 456 rtc::Optional<int64_t>()); |
450 EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); | 457 EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); |
451 } | 458 } |
452 | 459 |
453 // Verifies that the complexity adaptation in the config works as intended. | 460 // Verifies that the complexity adaptation in the config works as intended. |
454 TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) { | 461 TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) { |
455 AudioEncoderOpus::Config config; | 462 AudioEncoderOpusConfig config; |
456 config.low_rate_complexity = 8; | 463 config.low_rate_complexity = 8; |
457 config.complexity = 6; | 464 config.complexity = 6; |
458 | 465 |
459 // Bitrate within hysteresis window. Expect empty output. | 466 // Bitrate within hysteresis window. Expect empty output. |
460 config.bitrate_bps = rtc::Optional<int>(12500); | 467 config.bitrate_bps = rtc::Optional<int>(12500); |
461 EXPECT_EQ(rtc::Optional<int>(), config.GetNewComplexity()); | 468 EXPECT_EQ(rtc::Optional<int>(), AudioEncoderOpus::GetNewComplexity(config)); |
462 | 469 |
463 // Bitrate below hysteresis window. Expect higher complexity. | 470 // Bitrate below hysteresis window. Expect higher complexity. |
464 config.bitrate_bps = rtc::Optional<int>(10999); | 471 config.bitrate_bps = rtc::Optional<int>(10999); |
465 EXPECT_EQ(rtc::Optional<int>(8), config.GetNewComplexity()); | 472 EXPECT_EQ(rtc::Optional<int>(8), AudioEncoderOpus::GetNewComplexity(config)); |
466 | 473 |
467 // Bitrate within hysteresis window. Expect empty output. | 474 // Bitrate within hysteresis window. Expect empty output. |
468 config.bitrate_bps = rtc::Optional<int>(12500); | 475 config.bitrate_bps = rtc::Optional<int>(12500); |
469 EXPECT_EQ(rtc::Optional<int>(), config.GetNewComplexity()); | 476 EXPECT_EQ(rtc::Optional<int>(), AudioEncoderOpus::GetNewComplexity(config)); |
470 | 477 |
471 // Bitrate above hysteresis window. Expect lower complexity. | 478 // Bitrate above hysteresis window. Expect lower complexity. |
472 config.bitrate_bps = rtc::Optional<int>(14001); | 479 config.bitrate_bps = rtc::Optional<int>(14001); |
473 EXPECT_EQ(rtc::Optional<int>(6), config.GetNewComplexity()); | 480 EXPECT_EQ(rtc::Optional<int>(6), AudioEncoderOpus::GetNewComplexity(config)); |
474 } | 481 } |
475 | 482 |
476 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) { | 483 TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) { |
477 auto states = CreateCodec(2); | 484 auto states = CreateCodec(2); |
478 states.encoder->EnableAudioNetworkAdaptor("", nullptr); | 485 states.encoder->EnableAudioNetworkAdaptor("", nullptr); |
479 | 486 |
480 auto config = CreateEncoderRuntimeConfig(); | 487 auto config = CreateEncoderRuntimeConfig(); |
481 AudioEncoderRuntimeConfig empty_config; | 488 AudioEncoderRuntimeConfig empty_config; |
482 | 489 |
483 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) | 490 EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig()) |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
545 | 552 |
546 // Should encode now. | 553 // Should encode now. |
547 states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(), | 554 states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(), |
548 &encoded); | 555 &encoded); |
549 EXPECT_GT(encoded.size(), 0u); | 556 EXPECT_GT(encoded.size(), 0u); |
550 encoded.Clear(); | 557 encoded.Clear(); |
551 } | 558 } |
552 } | 559 } |
553 | 560 |
554 TEST(AudioEncoderOpusTest, TestConfigDefaults) { | 561 TEST(AudioEncoderOpusTest, TestConfigDefaults) { |
555 const AudioEncoderOpus::Config config = | 562 const auto config_opt = AudioEncoderOpus::SdpToConfig({"opus", 48000, 2}); |
556 AudioEncoderOpus::CreateConfig(0, {"opus", 48000, 2}); | 563 ASSERT_TRUE(config_opt); |
557 | 564 EXPECT_EQ(48000, config_opt->max_playback_rate_hz); |
558 EXPECT_EQ(48000, config.max_playback_rate_hz); | 565 EXPECT_EQ(1u, config_opt->num_channels); |
559 EXPECT_EQ(1u, config.num_channels); | 566 EXPECT_FALSE(config_opt->fec_enabled); |
560 EXPECT_FALSE(config.fec_enabled); | 567 EXPECT_FALSE(config_opt->dtx_enabled); |
561 EXPECT_FALSE(config.dtx_enabled); | 568 EXPECT_EQ(20, config_opt->frame_size_ms); |
562 EXPECT_EQ(20, config.frame_size_ms); | |
563 } | 569 } |
564 | 570 |
565 TEST(AudioEncoderOpusTest, TestConfigFromParams) { | 571 TEST(AudioEncoderOpusTest, TestConfigFromParams) { |
566 AudioEncoderOpus::Config config; | 572 const auto config1 = CreateConfigWithParameters({{"stereo", "0"}}); |
| 573 EXPECT_EQ(1U, config1.num_channels); |
567 | 574 |
568 config = CreateConfigWithParameters({{"stereo", "0"}}); | 575 const auto config2 = CreateConfigWithParameters({{"stereo", "1"}}); |
569 EXPECT_EQ(1U, config.num_channels); | 576 EXPECT_EQ(2U, config2.num_channels); |
570 | 577 |
571 config = CreateConfigWithParameters({{"stereo", "1"}}); | 578 const auto config3 = CreateConfigWithParameters({{"useinbandfec", "0"}}); |
572 EXPECT_EQ(2U, config.num_channels); | 579 EXPECT_FALSE(config3.fec_enabled); |
573 | 580 |
574 config = CreateConfigWithParameters({{"useinbandfec", "0"}}); | 581 const auto config4 = CreateConfigWithParameters({{"useinbandfec", "1"}}); |
575 EXPECT_FALSE(config.fec_enabled); | 582 EXPECT_TRUE(config4.fec_enabled); |
576 | 583 |
577 config = CreateConfigWithParameters({{"useinbandfec", "1"}}); | 584 const auto config5 = CreateConfigWithParameters({{"usedtx", "0"}}); |
578 EXPECT_TRUE(config.fec_enabled); | 585 EXPECT_FALSE(config5.dtx_enabled); |
579 | 586 |
580 config = CreateConfigWithParameters({{"usedtx", "0"}}); | 587 const auto config6 = CreateConfigWithParameters({{"usedtx", "1"}}); |
581 EXPECT_FALSE(config.dtx_enabled); | 588 EXPECT_TRUE(config6.dtx_enabled); |
582 | 589 |
583 config = CreateConfigWithParameters({{"usedtx", "1"}}); | 590 const auto config7 = CreateConfigWithParameters({{"cbr", "0"}}); |
584 EXPECT_TRUE(config.dtx_enabled); | 591 EXPECT_FALSE(config7.cbr_enabled); |
585 | 592 |
586 config = CreateConfigWithParameters({{"cbr", "0"}}); | 593 const auto config8 = CreateConfigWithParameters({{"cbr", "1"}}); |
587 EXPECT_FALSE(config.cbr_enabled); | 594 EXPECT_TRUE(config8.cbr_enabled); |
588 | 595 |
589 config = CreateConfigWithParameters({{"cbr", "1"}}); | 596 const auto config9 = |
590 EXPECT_TRUE(config.cbr_enabled); | 597 CreateConfigWithParameters({{"maxplaybackrate", "12345"}}); |
| 598 EXPECT_EQ(12345, config9.max_playback_rate_hz); |
591 | 599 |
592 config = CreateConfigWithParameters({{"maxplaybackrate", "12345"}}); | 600 const auto config10 = |
593 EXPECT_EQ(12345, config.max_playback_rate_hz); | 601 CreateConfigWithParameters({{"maxaveragebitrate", "96000"}}); |
| 602 EXPECT_EQ(96000, config10.bitrate_bps); |
594 | 603 |
595 config = CreateConfigWithParameters({{"maxaveragebitrate", "96000"}}); | 604 const auto config11 = CreateConfigWithParameters({{"maxptime", "40"}}); |
596 EXPECT_EQ(96000, config.bitrate_bps); | 605 for (int frame_length : config11.supported_frame_lengths_ms) { |
597 | |
598 config = CreateConfigWithParameters({{"maxptime", "40"}}); | |
599 for (int frame_length : config.supported_frame_lengths_ms) { | |
600 EXPECT_LE(frame_length, 40); | 606 EXPECT_LE(frame_length, 40); |
601 } | 607 } |
602 | 608 |
603 config = CreateConfigWithParameters({{"minptime", "40"}}); | 609 const auto config12 = CreateConfigWithParameters({{"minptime", "40"}}); |
604 for (int frame_length : config.supported_frame_lengths_ms) { | 610 for (int frame_length : config12.supported_frame_lengths_ms) { |
605 EXPECT_GE(frame_length, 40); | 611 EXPECT_GE(frame_length, 40); |
606 } | 612 } |
607 | 613 |
608 config = CreateConfigWithParameters({{"ptime", "40"}}); | 614 const auto config13 = CreateConfigWithParameters({{"ptime", "40"}}); |
609 EXPECT_EQ(40, config.frame_size_ms); | 615 EXPECT_EQ(40, config13.frame_size_ms); |
610 | 616 |
611 constexpr int kMinSupportedFrameLength = 10; | 617 constexpr int kMinSupportedFrameLength = 10; |
612 constexpr int kMaxSupportedFrameLength = | 618 constexpr int kMaxSupportedFrameLength = |
613 WEBRTC_OPUS_SUPPORT_120MS_PTIME ? 120 : 60; | 619 WEBRTC_OPUS_SUPPORT_120MS_PTIME ? 120 : 60; |
614 | 620 |
615 config = CreateConfigWithParameters({{"ptime", "1"}}); | 621 const auto config14 = CreateConfigWithParameters({{"ptime", "1"}}); |
616 EXPECT_EQ(kMinSupportedFrameLength, config.frame_size_ms); | 622 EXPECT_EQ(kMinSupportedFrameLength, config14.frame_size_ms); |
617 | 623 |
618 config = CreateConfigWithParameters({{"ptime", "2000"}}); | 624 const auto config15 = CreateConfigWithParameters({{"ptime", "2000"}}); |
619 EXPECT_EQ(kMaxSupportedFrameLength, config.frame_size_ms); | 625 EXPECT_EQ(kMaxSupportedFrameLength, config15.frame_size_ms); |
620 } | 626 } |
621 | 627 |
622 TEST(AudioEncoderOpusTest, TestConfigFromInvalidParams) { | 628 TEST(AudioEncoderOpusTest, TestConfigFromInvalidParams) { |
623 const webrtc::SdpAudioFormat format("opus", 48000, 2); | 629 const webrtc::SdpAudioFormat format("opus", 48000, 2); |
624 const AudioEncoderOpus::Config default_config = | 630 const auto default_config = *AudioEncoderOpus::SdpToConfig(format); |
625 AudioEncoderOpus::CreateConfig(0, format); | |
626 #if WEBRTC_OPUS_SUPPORT_120MS_PTIME | 631 #if WEBRTC_OPUS_SUPPORT_120MS_PTIME |
627 const std::vector<int> default_supported_frame_lengths_ms({20, 60, 120}); | 632 const std::vector<int> default_supported_frame_lengths_ms({20, 60, 120}); |
628 #else | 633 #else |
629 const std::vector<int> default_supported_frame_lengths_ms({20, 60}); | 634 const std::vector<int> default_supported_frame_lengths_ms({20, 60}); |
630 #endif | 635 #endif |
631 | 636 |
632 AudioEncoderOpus::Config config; | 637 AudioEncoderOpusConfig config; |
633 config = CreateConfigWithParameters({{"stereo", "invalid"}}); | 638 config = CreateConfigWithParameters({{"stereo", "invalid"}}); |
634 EXPECT_EQ(default_config.num_channels, config.num_channels); | 639 EXPECT_EQ(default_config.num_channels, config.num_channels); |
635 | 640 |
636 config = CreateConfigWithParameters({{"useinbandfec", "invalid"}}); | 641 config = CreateConfigWithParameters({{"useinbandfec", "invalid"}}); |
637 EXPECT_EQ(default_config.fec_enabled, config.fec_enabled); | 642 EXPECT_EQ(default_config.fec_enabled, config.fec_enabled); |
638 | 643 |
639 config = CreateConfigWithParameters({{"usedtx", "invalid"}}); | 644 config = CreateConfigWithParameters({{"usedtx", "invalid"}}); |
640 EXPECT_EQ(default_config.dtx_enabled, config.dtx_enabled); | 645 EXPECT_EQ(default_config.dtx_enabled, config.dtx_enabled); |
641 | 646 |
642 config = CreateConfigWithParameters({{"cbr", "invalid"}}); | 647 config = CreateConfigWithParameters({{"cbr", "invalid"}}); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
674 config = CreateConfigWithParameters({{"ptime", "invalid"}}); | 679 config = CreateConfigWithParameters({{"ptime", "invalid"}}); |
675 EXPECT_EQ(default_supported_frame_lengths_ms, | 680 EXPECT_EQ(default_supported_frame_lengths_ms, |
676 config.supported_frame_lengths_ms); | 681 config.supported_frame_lengths_ms); |
677 } | 682 } |
678 | 683 |
679 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | 684 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. |
680 // Also test that the "maxaveragebitrate" can't be set to values outside the | 685 // Also test that the "maxaveragebitrate" can't be set to values outside the |
681 // range of 6000 and 510000 | 686 // range of 6000 and 510000 |
682 TEST(AudioEncoderOpusTest, SetSendCodecOpusMaxAverageBitrate) { | 687 TEST(AudioEncoderOpusTest, SetSendCodecOpusMaxAverageBitrate) { |
683 // Ignore if less than 6000. | 688 // Ignore if less than 6000. |
684 const AudioEncoderOpus::Config config1 = AudioEncoderOpus::CreateConfig( | 689 const auto config1 = AudioEncoderOpus::SdpToConfig( |
685 0, {"opus", 48000, 2, {{"maxaveragebitrate", "5999"}}}); | 690 {"opus", 48000, 2, {{"maxaveragebitrate", "5999"}}}); |
686 EXPECT_EQ(6000, config1.bitrate_bps); | 691 EXPECT_EQ(6000, config1->bitrate_bps); |
687 | 692 |
688 // Ignore if larger than 510000. | 693 // Ignore if larger than 510000. |
689 const AudioEncoderOpus::Config config2 = AudioEncoderOpus::CreateConfig( | 694 const auto config2 = AudioEncoderOpus::SdpToConfig( |
690 0, {"opus", 48000, 2, {{"maxaveragebitrate", "510001"}}}); | 695 {"opus", 48000, 2, {{"maxaveragebitrate", "510001"}}}); |
691 EXPECT_EQ(510000, config2.bitrate_bps); | 696 EXPECT_EQ(510000, config2->bitrate_bps); |
692 | 697 |
693 const AudioEncoderOpus::Config config3 = AudioEncoderOpus::CreateConfig( | 698 const auto config3 = AudioEncoderOpus::SdpToConfig( |
694 0, {"opus", 48000, 2, {{"maxaveragebitrate", "200000"}}}); | 699 {"opus", 48000, 2, {{"maxaveragebitrate", "200000"}}}); |
695 EXPECT_EQ(200000, config3.bitrate_bps); | 700 EXPECT_EQ(200000, config3->bitrate_bps); |
696 } | 701 } |
697 | 702 |
698 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | 703 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. |
699 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateNb) { | 704 TEST(AudioEncoderOpusTest, SetMaxPlaybackRateNb) { |
700 auto config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}}); | 705 auto config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}}); |
701 EXPECT_EQ(8000, config.max_playback_rate_hz); | 706 EXPECT_EQ(8000, config.max_playback_rate_hz); |
702 EXPECT_EQ(12000, config.bitrate_bps); | 707 EXPECT_EQ(12000, config.bitrate_bps); |
703 | 708 |
704 config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}, | 709 config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}, |
705 {"stereo", "1"}}); | 710 {"stereo", "1"}}); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
749 EXPECT_EQ(24001, config.max_playback_rate_hz); | 754 EXPECT_EQ(24001, config.max_playback_rate_hz); |
750 EXPECT_EQ(32000, config.bitrate_bps); | 755 EXPECT_EQ(32000, config.bitrate_bps); |
751 | 756 |
752 config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}, | 757 config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}, |
753 {"stereo", "1"}}); | 758 {"stereo", "1"}}); |
754 EXPECT_EQ(24001, config.max_playback_rate_hz); | 759 EXPECT_EQ(24001, config.max_playback_rate_hz); |
755 EXPECT_EQ(64000, config.bitrate_bps); | 760 EXPECT_EQ(64000, config.bitrate_bps); |
756 } | 761 } |
757 | 762 |
758 } // namespace webrtc | 763 } // namespace webrtc |
OLD | NEW |