Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1162)

Side by Side Diff: webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc

Issue 2948483002: Opus implementation of the AudioEncoderFactoryTemplate API (Closed)
Patch Set: rebase Created 3 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698