OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2008 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2008 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 19 matching lines...) Expand all Loading... | |
30 #include "webrtc/pc/channel.h" | 30 #include "webrtc/pc/channel.h" |
31 #include "webrtc/test/field_trial.h" | 31 #include "webrtc/test/field_trial.h" |
32 | 32 |
33 using testing::Return; | 33 using testing::Return; |
34 using testing::StrictMock; | 34 using testing::StrictMock; |
35 | 35 |
36 namespace { | 36 namespace { |
37 | 37 |
38 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); | 38 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); |
39 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); | 39 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); |
40 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); | 40 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 32000, 2); |
ossu
2017/02/21 11:04:14
Stereo opus is 64kbps, mono is 32kbps. This value
kwiberg-webrtc
2017/02/21 23:35:03
Speculation: whoever wrote this thought that the "
| |
41 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); | 41 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); |
42 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); | 42 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); |
43 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); | 43 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); |
44 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); | 44 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); |
45 const cricket::AudioCodec | 45 const cricket::AudioCodec |
46 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); | 46 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); |
47 const cricket::AudioCodec | 47 const cricket::AudioCodec |
48 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); | 48 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); |
49 | 49 |
50 const uint32_t kSsrc1 = 0x99; | 50 const uint32_t kSsrc1 = 0x99; |
(...skipping 247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
298 cricket::AudioSendParameters send_parameters; | 298 cricket::AudioSendParameters send_parameters; |
299 send_parameters.codecs.push_back(codec); | 299 send_parameters.codecs.push_back(codec); |
300 send_parameters.max_bandwidth_bps = bitrate; | 300 send_parameters.max_bandwidth_bps = bitrate; |
301 SetSendParameters(send_parameters); | 301 SetSendParameters(send_parameters); |
302 } | 302 } |
303 | 303 |
304 void CheckSendCodec(int32_t ssrc, | 304 void CheckSendCodec(int32_t ssrc, |
305 const char expected_name[], | 305 const char expected_name[], |
306 int expected_channels, | 306 int expected_channels, |
307 int expected_bitrate) { | 307 int expected_bitrate) { |
308 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; | 308 const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec; |
309 EXPECT_STREQ(expected_name, codec.plname); | 309 EXPECT_EQ(expected_name, spec.format.format.name); |
310 EXPECT_EQ(expected_channels, codec.channels); | 310 EXPECT_EQ(expected_channels, spec.format.info.num_channels); |
311 EXPECT_EQ(expected_bitrate, codec.rate); | 311 EXPECT_EQ(expected_bitrate, spec.target_bitrate_bps); |
312 } | 312 } |
313 | 313 |
314 int GetOpusMaxPlaybackRate(int32_t ssrc) { | 314 rtc::Optional<int> GetCodecBitrate(int32_t ssrc) { |
315 return GetSendStreamConfig(ssrc).send_codec_spec.opus_max_playback_rate; | 315 return GetSendStreamConfig(ssrc).send_codec_spec.target_bitrate_bps; |
316 } | |
317 | |
318 bool GetOpusDtx(int32_t ssrc) { | |
319 return GetSendStreamConfig(ssrc).send_codec_spec.enable_opus_dtx; | |
320 } | |
321 | |
322 bool GetCodecFec(int32_t ssrc) { | |
323 return GetSendStreamConfig(ssrc).send_codec_spec.enable_codec_fec; | |
324 } | |
325 | |
326 int GetCodecBitrate(int32_t ssrc) { | |
327 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.rate; | |
328 } | |
329 | |
330 int GetCodecPacSize(int32_t ssrc) { | |
331 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.pacsize; | |
332 } | 316 } |
333 | 317 |
334 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { | 318 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { |
335 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; | 319 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; |
336 } | 320 } |
337 | 321 |
338 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, | 322 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
339 int global_max, | 323 int global_max, |
340 int stream_max, | 324 int stream_max, |
341 bool expected_result, | 325 bool expected_result, |
(...skipping 313 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
655 // Tests that the list of supported codecs is created properly and ordered | 639 // Tests that the list of supported codecs is created properly and ordered |
656 // correctly (such that opus appears first). | 640 // correctly (such that opus appears first). |
657 // TODO(ossu): This test should move into a separate builtin audio codecs | 641 // TODO(ossu): This test should move into a separate builtin audio codecs |
658 // module. | 642 // module. |
659 TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) { | 643 TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) { |
660 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | 644 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
661 ASSERT_FALSE(codecs.empty()); | 645 ASSERT_FALSE(codecs.empty()); |
662 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); | 646 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); |
663 EXPECT_EQ(48000, codecs[0].clockrate); | 647 EXPECT_EQ(48000, codecs[0].clockrate); |
664 EXPECT_EQ(2, codecs[0].channels); | 648 EXPECT_EQ(2, codecs[0].channels); |
665 EXPECT_EQ(64000, codecs[0].bitrate); | |
666 } | 649 } |
667 | 650 |
668 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { | 651 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { |
669 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | 652 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
670 bool opus_found = false; | 653 bool opus_found = false; |
671 for (cricket::AudioCodec codec : codecs) { | 654 for (cricket::AudioCodec codec : codecs) { |
672 if (codec.name == "opus") { | 655 if (codec.name == "opus") { |
673 EXPECT_TRUE(HasTransportCc(codec)); | 656 EXPECT_TRUE(HasTransportCc(codec)); |
674 opus_found = true; | 657 opus_found = true; |
675 } | 658 } |
676 } | 659 } |
677 EXPECT_TRUE(opus_found); | 660 EXPECT_TRUE(opus_found); |
678 } | 661 } |
679 | 662 |
680 // Tests that we can find codecs by name or id, and that we interpret the | |
ossu
2017/02/21 11:04:14
These are just removed because the underlying func
| |
681 // clockrate and bitrate fields properly. | |
682 TEST_F(WebRtcVoiceEngineTestFake, FindCodec) { | |
683 cricket::AudioCodec codec; | |
684 webrtc::CodecInst codec_inst; | |
685 // Find PCMU with explicit clockrate and bitrate. | |
686 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst)); | |
687 // Find ISAC with explicit clockrate and 0 bitrate. | |
688 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst)); | |
689 // Find telephone-event with explicit clockrate and 0 bitrate. | |
690 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec1, | |
691 &codec_inst)); | |
692 // Find telephone-event with explicit clockrate and 0 bitrate. | |
693 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec2, | |
694 &codec_inst)); | |
695 // Find ISAC with a different payload id. | |
696 codec = kIsacCodec; | |
697 codec.id = 127; | |
698 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
699 EXPECT_EQ(codec.id, codec_inst.pltype); | |
700 // Find PCMU with a 0 clockrate. | |
701 codec = kPcmuCodec; | |
702 codec.clockrate = 0; | |
703 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
704 EXPECT_EQ(codec.id, codec_inst.pltype); | |
705 EXPECT_EQ(8000, codec_inst.plfreq); | |
706 // Find PCMU with a 0 bitrate. | |
707 codec = kPcmuCodec; | |
708 codec.bitrate = 0; | |
709 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
710 EXPECT_EQ(codec.id, codec_inst.pltype); | |
711 EXPECT_EQ(64000, codec_inst.rate); | |
712 // Find ISAC with an explicit bitrate. | |
713 codec = kIsacCodec; | |
714 codec.bitrate = 32000; | |
715 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
716 EXPECT_EQ(codec.id, codec_inst.pltype); | |
717 EXPECT_EQ(32000, codec_inst.rate); | |
718 } | |
719 | |
720 // Test that we set our inbound codecs properly, including changing PT. | 663 // Test that we set our inbound codecs properly, including changing PT. |
721 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { | 664 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { |
722 EXPECT_TRUE(SetupChannel()); | 665 EXPECT_TRUE(SetupChannel()); |
723 cricket::AudioRecvParameters parameters; | 666 cricket::AudioRecvParameters parameters; |
724 parameters.codecs.push_back(kIsacCodec); | 667 parameters.codecs.push_back(kIsacCodec); |
725 parameters.codecs.push_back(kPcmuCodec); | 668 parameters.codecs.push_back(kPcmuCodec); |
726 parameters.codecs.push_back(kTelephoneEventCodec1); | 669 parameters.codecs.push_back(kTelephoneEventCodec1); |
727 parameters.codecs.push_back(kTelephoneEventCodec2); | 670 parameters.codecs.push_back(kTelephoneEventCodec2); |
728 parameters.codecs[0].id = 106; // collide with existing CN 32k | 671 parameters.codecs[0].id = 106; // collide with existing CN 32k |
729 parameters.codecs[2].id = 126; | 672 parameters.codecs[2].id = 126; |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
920 // Test that when autobw is enabled, bitrate is kept as the default | 863 // Test that when autobw is enabled, bitrate is kept as the default |
921 // value. autobw is enabled for the following tests because the target | 864 // value. autobw is enabled for the following tests because the target |
922 // bitrate is <= 0. | 865 // bitrate is <= 0. |
923 | 866 |
924 // ISAC, default bitrate == 32000. | 867 // ISAC, default bitrate == 32000. |
925 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); | 868 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); |
926 | 869 |
927 // PCMU, default bitrate == 64000. | 870 // PCMU, default bitrate == 64000. |
928 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); | 871 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); |
929 | 872 |
930 // opus, default bitrate == 64000. | 873 // opus, default bitrate == 32000 in mono. |
931 TestMaxSendBandwidth(kOpusCodec, -1, true, 64000); | 874 TestMaxSendBandwidth(kOpusCodec, -1, true, 32000); |
932 } | 875 } |
933 | 876 |
934 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { | 877 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { |
935 EXPECT_TRUE(SetupSendStream()); | 878 EXPECT_TRUE(SetupSendStream()); |
936 | 879 |
937 // Test that the bitrate of a multi-rate codec is always the maximum. | |
938 | |
939 // ISAC, default bitrate == 32000. | 880 // ISAC, default bitrate == 32000. |
940 TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000); | |
941 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); | 881 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); |
942 // Rates above the max (56000) should be capped. | 882 // Rates above the max (56000) should be capped. |
943 TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000); | 883 TestMaxSendBandwidth(kIsacCodec, 100000, true, 32000); |
kwiberg-webrtc
2017/02/21 23:35:03
Why did this change?
| |
944 | 884 |
945 // opus, default bitrate == 64000. | 885 // opus, default bitrate == 64000. |
946 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); | 886 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); |
947 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); | 887 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); |
948 // Rates above the max (510000) should be capped. | 888 // Rates above the max (510000) should be capped. |
949 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); | 889 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); |
950 } | 890 } |
951 | 891 |
952 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { | 892 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { |
953 EXPECT_TRUE(SetupSendStream()); | 893 EXPECT_TRUE(SetupSendStream()); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
996 send_parameters_.max_bandwidth_bps = 128; | 936 send_parameters_.max_bandwidth_bps = 128; |
997 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); | 937 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
998 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | 938 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); |
999 } | 939 } |
1000 | 940 |
1001 // Test that the per-stream bitrate limit and the global | 941 // Test that the per-stream bitrate limit and the global |
1002 // bitrate limit both apply. | 942 // bitrate limit both apply. |
1003 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { | 943 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
1004 EXPECT_TRUE(SetupSendStream()); | 944 EXPECT_TRUE(SetupSendStream()); |
1005 | 945 |
1006 // opus, default bitrate == 64000. | 946 // opus, default bitrate == 32000. |
1007 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); | 947 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000); |
1008 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); | 948 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); |
1009 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); | 949 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); |
1010 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); | 950 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); |
1011 | 951 |
1012 // CBR codecs allow both maximums to exceed the bitrate. | 952 // CBR codecs allow both maximums to exceed the bitrate. |
1013 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); | 953 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); |
1014 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); | 954 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); |
1015 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); | 955 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); |
1016 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); | 956 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); |
1017 | 957 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1082 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { | 1022 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { |
1083 SetupForMultiSendStream(); | 1023 SetupForMultiSendStream(); |
1084 // Create send streams. | 1024 // Create send streams. |
1085 for (uint32_t ssrc : kSsrcs4) { | 1025 for (uint32_t ssrc : kSsrcs4) { |
1086 EXPECT_TRUE( | 1026 EXPECT_TRUE( |
1087 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); | 1027 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); |
1088 } | 1028 } |
1089 // Configure one stream to be limited by the stream config, another to be | 1029 // Configure one stream to be limited by the stream config, another to be |
1090 // limited by the global max, and the third one with no per-stream limit | 1030 // limited by the global max, and the third one with no per-stream limit |
1091 // (still subject to the global limit). | 1031 // (still subject to the global limit). |
1092 SetGlobalMaxBitrate(kOpusCodec, 64000); | 1032 SetGlobalMaxBitrate(kOpusCodec, 32000); |
1093 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); | 1033 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000)); |
1094 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); | 1034 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000)); |
1095 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); | 1035 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); |
1096 | 1036 |
1097 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1037 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1098 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); | 1038 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1])); |
1099 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1039 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1100 | 1040 |
1101 // Remove the global cap; the streams should switch to their respective | 1041 // Remove the global cap; the streams should switch to their respective |
1102 // maximums (or remain unchanged if there was no other limit on them.) | 1042 // maximums (or remain unchanged if there was no other limit on them.) |
1103 SetGlobalMaxBitrate(kOpusCodec, -1); | 1043 SetGlobalMaxBitrate(kOpusCodec, -1); |
1104 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1044 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1105 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); | 1045 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1])); |
1106 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1046 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1107 } | 1047 } |
1108 | 1048 |
1109 // Test that GetRtpSendParameters returns the currently configured codecs. | 1049 // Test that GetRtpSendParameters returns the currently configured codecs. |
1110 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { | 1050 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { |
1111 EXPECT_TRUE(SetupSendStream()); | 1051 EXPECT_TRUE(SetupSendStream()); |
1112 cricket::AudioSendParameters parameters; | 1052 cricket::AudioSendParameters parameters; |
1113 parameters.codecs.push_back(kIsacCodec); | 1053 parameters.codecs.push_back(kIsacCodec); |
1114 parameters.codecs.push_back(kPcmuCodec); | 1054 parameters.codecs.push_back(kPcmuCodec); |
1115 SetSendParameters(parameters); | 1055 SetSendParameters(parameters); |
1116 | 1056 |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1196 cricket::AudioSendParameters parameters; | 1136 cricket::AudioSendParameters parameters; |
1197 parameters.codecs.push_back(kIsacCodec); | 1137 parameters.codecs.push_back(kIsacCodec); |
1198 parameters.codecs.push_back(kPcmuCodec); | 1138 parameters.codecs.push_back(kPcmuCodec); |
1199 parameters.codecs.push_back(kCn8000Codec); | 1139 parameters.codecs.push_back(kCn8000Codec); |
1200 parameters.codecs[0].id = 96; | 1140 parameters.codecs[0].id = 96; |
1201 parameters.codecs[0].bitrate = 48000; | 1141 parameters.codecs[0].bitrate = 48000; |
1202 const int initial_num = call_.GetNumCreatedSendStreams(); | 1142 const int initial_num = call_.GetNumCreatedSendStreams(); |
1203 SetSendParameters(parameters); | 1143 SetSendParameters(parameters); |
1204 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1144 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1205 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1145 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1206 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1146 EXPECT_EQ(96, send_codec_spec.payload_type); |
1207 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); | 1147 // EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); |
1208 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1148 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
1209 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1149 EXPECT_NE(send_codec_spec.format.format.clockrate_hz, |
1150 send_codec_spec.cng_plfreq); | |
1210 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1151 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
1211 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | 1152 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1212 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1153 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1213 } | 1154 } |
1214 | 1155 |
1215 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1156 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried |
1216 // to apply. | 1157 // to apply. |
1217 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1158 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { |
1218 EXPECT_TRUE(SetupSendStream()); | 1159 EXPECT_TRUE(SetupSendStream()); |
1219 cricket::AudioSendParameters parameters; | 1160 cricket::AudioSendParameters parameters; |
1220 parameters.codecs.push_back(kIsacCodec); | 1161 parameters.codecs.push_back(kIsacCodec); |
1221 parameters.codecs.push_back(kPcmuCodec); | 1162 parameters.codecs.push_back(kPcmuCodec); |
1222 parameters.codecs.push_back(kCn8000Codec); | 1163 parameters.codecs.push_back(kCn8000Codec); |
1223 parameters.codecs[0].id = 96; | 1164 parameters.codecs[0].id = 96; |
1224 parameters.codecs[0].bitrate = 48000; | 1165 parameters.codecs[0].bitrate = 48000; |
1225 const int initial_num = call_.GetNumCreatedSendStreams(); | 1166 const int initial_num = call_.GetNumCreatedSendStreams(); |
1226 SetSendParameters(parameters); | 1167 SetSendParameters(parameters); |
1227 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1168 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1228 // Calling SetSendCodec again with same codec which is already set. | 1169 // Calling SetSendCodec again with same codec which is already set. |
1229 // In this case media channel shouldn't send codec to VoE. | 1170 // In this case media channel shouldn't send codec to VoE. |
1230 SetSendParameters(parameters); | 1171 SetSendParameters(parameters); |
1231 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1172 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); |
1232 } | 1173 } |
1233 | 1174 |
1234 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1175 // TODO(ossu): Move these tests into tests for Audio{Encoder,Decoder}Opus or, |
ossu
2017/02/21 11:04:15
The clock rate <-> sample rate functionality is no
kwiberg-webrtc
2017/02/21 23:35:03
Acknowledged.
| |
1235 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1176 // possibly, BuiltinAudio{Encoder,Decoder}Factory; this depends on where we move |
1236 EXPECT_TRUE(SetupSendStream()); | 1177 // validation. |
1237 cricket::AudioSendParameters parameters; | |
1238 parameters.codecs.push_back(kG722CodecSdp); | |
1239 SetSendParameters(parameters); | |
1240 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | |
1241 EXPECT_STREQ("G722", gcodec.plname); | |
1242 EXPECT_EQ(1, gcodec.channels); | |
1243 EXPECT_EQ(16000, gcodec.plfreq); | |
1244 } | |
1245 | 1178 |
1246 // Test that if clockrate is not 48000 for opus, we fail. | 1179 // Test that if clockrate is not 48000 for opus, we fail. |
1247 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1180 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1248 EXPECT_TRUE(SetupSendStream()); | 1181 EXPECT_TRUE(SetupSendStream()); |
1249 cricket::AudioSendParameters parameters; | 1182 cricket::AudioSendParameters parameters; |
1250 parameters.codecs.push_back(kOpusCodec); | 1183 parameters.codecs.push_back(kOpusCodec); |
1251 parameters.codecs[0].bitrate = 0; | 1184 parameters.codecs[0].bitrate = 0; |
1252 parameters.codecs[0].clockrate = 50000; | 1185 parameters.codecs[0].clockrate = 50000; |
1253 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1186 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1254 } | 1187 } |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1376 } | 1309 } |
1377 | 1310 |
1378 // Test that with bitrate=N and stereo unset, | 1311 // Test that with bitrate=N and stereo unset, |
1379 // channels and bitrate are 1 and N. | 1312 // channels and bitrate are 1 and N. |
1380 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1313 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1381 EXPECT_TRUE(SetupSendStream()); | 1314 EXPECT_TRUE(SetupSendStream()); |
1382 cricket::AudioSendParameters parameters; | 1315 cricket::AudioSendParameters parameters; |
1383 parameters.codecs.push_back(kOpusCodec); | 1316 parameters.codecs.push_back(kOpusCodec); |
1384 parameters.codecs[0].bitrate = 96000; | 1317 parameters.codecs[0].bitrate = 96000; |
1385 SetSendParameters(parameters); | 1318 SetSendParameters(parameters); |
1386 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1319 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1387 EXPECT_EQ(111, gcodec.pltype); | 1320 EXPECT_EQ(111, spec.payload_type); |
1388 EXPECT_EQ(96000, gcodec.rate); | 1321 EXPECT_EQ(96000, spec.target_bitrate_bps); |
1389 EXPECT_STREQ("opus", gcodec.plname); | 1322 EXPECT_EQ("opus", spec.format.format.name); |
1390 EXPECT_EQ(1, gcodec.channels); | 1323 EXPECT_EQ(1, spec.format.info.num_channels); |
1391 EXPECT_EQ(48000, gcodec.plfreq); | 1324 EXPECT_EQ(48000, spec.format.info.sample_rate_hz); |
1325 EXPECT_EQ(48000, spec.format.format.clockrate_hz); | |
1392 } | 1326 } |
1393 | 1327 |
1394 // Test that with bitrate=N and stereo=0, | 1328 // Test that with bitrate=N and stereo=0, |
1395 // channels and bitrate are 1 and N. | 1329 // channels and bitrate are 1 and N. |
1396 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1330 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1397 EXPECT_TRUE(SetupSendStream()); | 1331 EXPECT_TRUE(SetupSendStream()); |
1398 cricket::AudioSendParameters parameters; | 1332 cricket::AudioSendParameters parameters; |
1399 parameters.codecs.push_back(kOpusCodec); | 1333 parameters.codecs.push_back(kOpusCodec); |
1400 parameters.codecs[0].bitrate = 30000; | 1334 parameters.codecs[0].bitrate = 30000; |
1401 parameters.codecs[0].params["stereo"] = "0"; | 1335 parameters.codecs[0].params["stereo"] = "0"; |
(...skipping 17 matching lines...) Expand all Loading... | |
1419 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1353 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1420 EXPECT_TRUE(SetupSendStream()); | 1354 EXPECT_TRUE(SetupSendStream()); |
1421 cricket::AudioSendParameters parameters; | 1355 cricket::AudioSendParameters parameters; |
1422 parameters.codecs.push_back(kOpusCodec); | 1356 parameters.codecs.push_back(kOpusCodec); |
1423 parameters.codecs[0].bitrate = 30000; | 1357 parameters.codecs[0].bitrate = 30000; |
1424 parameters.codecs[0].params["stereo"] = "1"; | 1358 parameters.codecs[0].params["stereo"] = "1"; |
1425 SetSendParameters(parameters); | 1359 SetSendParameters(parameters); |
1426 CheckSendCodec(kSsrc1, "opus", 2, 30000); | 1360 CheckSendCodec(kSsrc1, "opus", 2, 30000); |
1427 } | 1361 } |
1428 | 1362 |
1429 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | |
ossu
2017/02/21 11:04:14
Moved into AudioEncoderOpus unit tests.
| |
1430 // Also test that the "maxaveragebitrate" can't be set to values outside the | |
1431 // range of 6000 and 510000 | |
1432 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | |
1433 EXPECT_TRUE(SetupSendStream()); | |
1434 cricket::AudioSendParameters parameters; | |
1435 parameters.codecs.push_back(kOpusCodec); | |
1436 parameters.codecs[0].bitrate = 30000; | |
1437 // Ignore if less than 6000. | |
1438 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | |
1439 SetSendParameters(parameters); | |
1440 EXPECT_EQ(6000, GetCodecBitrate(kSsrc1)); | |
1441 | |
1442 // Ignore if larger than 510000. | |
1443 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | |
1444 SetSendParameters(parameters); | |
1445 EXPECT_EQ(510000, GetCodecBitrate(kSsrc1)); | |
1446 | |
1447 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | |
1448 SetSendParameters(parameters); | |
1449 EXPECT_EQ(200000, GetCodecBitrate(kSsrc1)); | |
1450 } | |
1451 | |
1452 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { | 1363 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { |
1453 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", | 1364 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
1454 200000); | 1365 200000); |
1455 } | 1366 } |
1456 | 1367 |
1457 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { | 1368 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { |
1458 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); | 1369 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); |
1459 } | 1370 } |
1460 | 1371 |
1461 TEST_F(WebRtcVoiceEngineTestFake, | 1372 TEST_F(WebRtcVoiceEngineTestFake, |
(...skipping 113 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1575 cricket::kParamValueEmpty)); | 1486 cricket::kParamValueEmpty)); |
1576 SetSendParameters(parameters); | 1487 SetSendParameters(parameters); |
1577 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); | 1488 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrc1).rtp.nack.rtp_history_ms); |
1578 | 1489 |
1579 EXPECT_TRUE(AddRecvStream(kSsrc2)); | 1490 EXPECT_TRUE(AddRecvStream(kSsrc2)); |
1580 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); | 1491 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc2).rtp.nack.rtp_history_ms); |
1581 EXPECT_TRUE(AddRecvStream(kSsrc3)); | 1492 EXPECT_TRUE(AddRecvStream(kSsrc3)); |
1582 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); | 1493 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrc3).rtp.nack.rtp_history_ms); |
1583 } | 1494 } |
1584 | 1495 |
1585 // Test that without useinbandfec, Opus FEC is off. | |
ossu
2017/02/21 11:04:14
These are all moved into AudioEncoderOpus unit tes
| |
1586 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | |
1587 EXPECT_TRUE(SetupSendStream()); | |
1588 cricket::AudioSendParameters parameters; | |
1589 parameters.codecs.push_back(kOpusCodec); | |
1590 SetSendParameters(parameters); | |
1591 EXPECT_FALSE(GetCodecFec(kSsrc1)); | |
1592 } | |
1593 | |
1594 // Test that with useinbandfec=0, Opus FEC is off. | |
1595 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | |
1596 EXPECT_TRUE(SetupSendStream()); | |
1597 cricket::AudioSendParameters parameters; | |
1598 parameters.codecs.push_back(kOpusCodec); | |
1599 parameters.codecs[0].bitrate = 0; | |
1600 parameters.codecs[0].params["useinbandfec"] = "0"; | |
1601 SetSendParameters(parameters); | |
1602 CheckSendCodec(kSsrc1, "opus", 1, 32000); | |
1603 } | |
1604 | |
1605 // Test that with useinbandfec=1, Opus FEC is on. | |
1606 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | |
1607 EXPECT_TRUE(SetupSendStream()); | |
1608 cricket::AudioSendParameters parameters; | |
1609 parameters.codecs.push_back(kOpusCodec); | |
1610 parameters.codecs[0].bitrate = 0; | |
1611 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1612 SetSendParameters(parameters); | |
1613 EXPECT_TRUE(GetCodecFec(kSsrc1)); | |
1614 CheckSendCodec(kSsrc1, "opus", 1, 32000); | |
1615 } | |
1616 | |
1617 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | |
1618 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | |
1619 EXPECT_TRUE(SetupSendStream()); | |
1620 cricket::AudioSendParameters parameters; | |
1621 parameters.codecs.push_back(kOpusCodec); | |
1622 parameters.codecs[0].bitrate = 0; | |
1623 parameters.codecs[0].params["stereo"] = "1"; | |
1624 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1625 SetSendParameters(parameters); | |
1626 EXPECT_TRUE(GetCodecFec(kSsrc1)); | |
1627 CheckSendCodec(kSsrc1, "opus", 2, 64000); | |
1628 } | |
1629 | |
1630 // Test that with non-Opus, codec FEC is off. | |
1631 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | |
1632 EXPECT_TRUE(SetupSendStream()); | |
1633 cricket::AudioSendParameters parameters; | |
1634 parameters.codecs.push_back(kIsacCodec); | |
1635 SetSendParameters(parameters); | |
1636 EXPECT_FALSE(GetCodecFec(kSsrc1)); | |
1637 } | |
1638 | |
1639 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | |
1640 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | |
1641 EXPECT_TRUE(SetupSendStream()); | |
1642 cricket::AudioSendParameters parameters; | |
1643 parameters.codecs.push_back(kIsacCodec); | |
1644 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1645 SetSendParameters(parameters); | |
1646 EXPECT_FALSE(GetCodecFec(kSsrc1)); | |
1647 } | |
1648 | |
1649 // Test that Opus FEC status can be changed. | |
1650 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | |
1651 EXPECT_TRUE(SetupSendStream()); | |
1652 cricket::AudioSendParameters parameters; | |
1653 parameters.codecs.push_back(kOpusCodec); | |
1654 SetSendParameters(parameters); | |
1655 EXPECT_FALSE(GetCodecFec(kSsrc1)); | |
1656 | |
1657 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1658 SetSendParameters(parameters); | |
1659 EXPECT_TRUE(GetCodecFec(kSsrc1)); | |
1660 } | |
1661 | |
1662 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1496 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1663 EXPECT_TRUE(SetupChannel()); | 1497 EXPECT_TRUE(SetupChannel()); |
1664 cricket::AudioSendParameters send_parameters; | 1498 cricket::AudioSendParameters send_parameters; |
1665 send_parameters.codecs.push_back(kOpusCodec); | 1499 send_parameters.codecs.push_back(kOpusCodec); |
1666 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1500 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1667 SetSendParameters(send_parameters); | 1501 SetSendParameters(send_parameters); |
1668 | 1502 |
1669 cricket::AudioRecvParameters recv_parameters; | 1503 cricket::AudioRecvParameters recv_parameters; |
1670 recv_parameters.codecs.push_back(kIsacCodec); | 1504 recv_parameters.codecs.push_back(kIsacCodec); |
1671 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1505 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1672 EXPECT_TRUE(AddRecvStream(kSsrc1)); | 1506 EXPECT_TRUE(AddRecvStream(kSsrc1)); |
1673 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1507 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1674 EXPECT_FALSE( | 1508 EXPECT_FALSE( |
1675 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1509 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1676 | 1510 |
1677 send_parameters.codecs = engine_->send_codecs(); | 1511 send_parameters.codecs = engine_->send_codecs(); |
1678 SetSendParameters(send_parameters); | 1512 SetSendParameters(send_parameters); |
1679 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); | 1513 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrc1) != nullptr); |
1680 EXPECT_TRUE( | 1514 EXPECT_TRUE( |
1681 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); | 1515 call_.GetAudioReceiveStream(kSsrc1)->GetConfig().rtp.transport_cc); |
1682 } | 1516 } |
1683 | 1517 |
1684 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | |
ossu
2017/02/21 11:04:14
Moved into AudioEncoderOpus unit tests.
| |
1685 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | |
1686 EXPECT_TRUE(SetupSendStream()); | |
1687 cricket::AudioSendParameters parameters; | |
1688 parameters.codecs.push_back(kOpusCodec); | |
1689 parameters.codecs[0].bitrate = 0; | |
1690 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1691 SetSendParameters(parameters); | |
1692 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); | |
1693 EXPECT_EQ(12000, GetCodecBitrate(kSsrc1)); | |
1694 | |
1695 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1696 SetSendParameters(parameters); | |
1697 EXPECT_EQ(24000, GetCodecBitrate(kSsrc1)); | |
1698 } | |
1699 | |
1700 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | |
1701 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | |
1702 EXPECT_TRUE(SetupSendStream()); | |
1703 cricket::AudioSendParameters parameters; | |
1704 parameters.codecs.push_back(kOpusCodec); | |
1705 parameters.codecs[0].bitrate = 0; | |
1706 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | |
1707 SetSendParameters(parameters); | |
1708 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrc1)); | |
1709 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); | |
1710 | |
1711 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1712 SetSendParameters(parameters); | |
1713 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); | |
1714 } | |
1715 | |
1716 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | |
1717 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | |
1718 EXPECT_TRUE(SetupSendStream()); | |
1719 cricket::AudioSendParameters parameters; | |
1720 parameters.codecs.push_back(kOpusCodec); | |
1721 parameters.codecs[0].bitrate = 0; | |
1722 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | |
1723 SetSendParameters(parameters); | |
1724 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrc1)); | |
1725 EXPECT_EQ(20000, GetCodecBitrate(kSsrc1)); | |
1726 | |
1727 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1728 SetSendParameters(parameters); | |
1729 EXPECT_EQ(40000, GetCodecBitrate(kSsrc1)); | |
1730 } | |
1731 | |
1732 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | |
1733 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | |
1734 EXPECT_TRUE(SetupSendStream()); | |
1735 cricket::AudioSendParameters parameters; | |
1736 parameters.codecs.push_back(kOpusCodec); | |
1737 parameters.codecs[0].bitrate = 0; | |
1738 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | |
1739 SetSendParameters(parameters); | |
1740 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrc1)); | |
1741 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); | |
1742 | |
1743 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1744 SetSendParameters(parameters); | |
1745 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | |
1746 } | |
1747 | |
1748 // Test 24000 < maxplaybackrate triggers Opus full band mode. | |
1749 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | |
1750 EXPECT_TRUE(SetupSendStream()); | |
1751 cricket::AudioSendParameters parameters; | |
1752 parameters.codecs.push_back(kOpusCodec); | |
1753 parameters.codecs[0].bitrate = 0; | |
1754 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | |
1755 SetSendParameters(parameters); | |
1756 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrc1)); | |
1757 EXPECT_EQ(32000, GetCodecBitrate(kSsrc1)); | |
1758 | |
1759 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1760 SetSendParameters(parameters); | |
1761 EXPECT_EQ(64000, GetCodecBitrate(kSsrc1)); | |
1762 } | |
1763 | |
1764 // Test Opus that without maxplaybackrate, default playback rate is used. | |
1765 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | |
1766 EXPECT_TRUE(SetupSendStream()); | |
1767 cricket::AudioSendParameters parameters; | |
1768 parameters.codecs.push_back(kOpusCodec); | |
1769 SetSendParameters(parameters); | |
1770 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); | |
1771 } | |
1772 | |
1773 // Test the with non-Opus, maxplaybackrate has no effect. | |
1774 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | |
1775 EXPECT_TRUE(SetupSendStream()); | |
1776 cricket::AudioSendParameters parameters; | |
1777 parameters.codecs.push_back(kIsacCodec); | |
1778 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | |
1779 SetSendParameters(parameters); | |
1780 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrc1)); | |
1781 } | |
1782 | |
1783 // Test maxplaybackrate can be set on two streams. | |
1784 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | |
1785 EXPECT_TRUE(SetupSendStream()); | |
1786 cricket::AudioSendParameters parameters; | |
1787 parameters.codecs.push_back(kOpusCodec); | |
1788 SetSendParameters(parameters); | |
1789 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrc1)); | |
1790 | |
1791 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1792 SetSendParameters(parameters); | |
1793 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc1)); | |
1794 | |
1795 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc2)); | |
1796 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrc2)); | |
1797 } | |
1798 | |
1799 // Test that with usedtx=0, Opus DTX is off. | |
1800 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | |
1801 EXPECT_TRUE(SetupSendStream()); | |
1802 cricket::AudioSendParameters parameters; | |
1803 parameters.codecs.push_back(kOpusCodec); | |
1804 parameters.codecs[0].params["usedtx"] = "0"; | |
1805 SetSendParameters(parameters); | |
1806 EXPECT_FALSE(GetOpusDtx(kSsrc1)); | |
1807 } | |
1808 | |
1809 // Test that with usedtx=1, Opus DTX is on. | |
1810 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | |
1811 EXPECT_TRUE(SetupSendStream()); | |
1812 cricket::AudioSendParameters parameters; | |
1813 parameters.codecs.push_back(kOpusCodec); | |
1814 parameters.codecs[0].params["usedtx"] = "1"; | |
1815 SetSendParameters(parameters); | |
1816 EXPECT_TRUE(GetOpusDtx(kSsrc1)); | |
1817 } | |
1818 | |
1819 // Test that usedtx=1 works with stereo Opus. | |
1820 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | |
1821 EXPECT_TRUE(SetupSendStream()); | |
1822 cricket::AudioSendParameters parameters; | |
1823 parameters.codecs.push_back(kOpusCodec); | |
1824 parameters.codecs[0].params["usedtx"] = "1"; | |
1825 parameters.codecs[0].params["stereo"] = "1"; | |
1826 SetSendParameters(parameters); | |
1827 EXPECT_TRUE(GetOpusDtx(kSsrc1)); | |
1828 } | |
1829 | |
1830 // Test that usedtx=1 does not work with non Opus. | |
1831 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | |
1832 EXPECT_TRUE(SetupSendStream()); | |
1833 cricket::AudioSendParameters parameters; | |
1834 parameters.codecs.push_back(kIsacCodec); | |
1835 parameters.codecs[0].params["usedtx"] = "1"; | |
1836 SetSendParameters(parameters); | |
1837 EXPECT_FALSE(GetOpusDtx(kSsrc1)); | |
1838 } | |
1839 | |
1840 // Test that we can switch back and forth between Opus and ISAC with CN. | 1518 // Test that we can switch back and forth between Opus and ISAC with CN. |
1841 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1519 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1842 EXPECT_TRUE(SetupSendStream()); | 1520 EXPECT_TRUE(SetupSendStream()); |
1843 | 1521 |
1844 cricket::AudioSendParameters opus_parameters; | 1522 cricket::AudioSendParameters opus_parameters; |
1845 opus_parameters.codecs.push_back(kOpusCodec); | 1523 opus_parameters.codecs.push_back(kOpusCodec); |
1846 SetSendParameters(opus_parameters); | 1524 SetSendParameters(opus_parameters); |
1847 { | 1525 { |
1848 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1526 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1849 EXPECT_EQ(111, gcodec.pltype); | 1527 EXPECT_EQ(111, spec.payload_type); |
1850 EXPECT_STREQ("opus", gcodec.plname); | 1528 EXPECT_STRCASEEQ("opus", spec.format.format.name.c_str()); |
1851 } | 1529 } |
1852 | 1530 |
1853 cricket::AudioSendParameters isac_parameters; | 1531 cricket::AudioSendParameters isac_parameters; |
1854 isac_parameters.codecs.push_back(kIsacCodec); | 1532 isac_parameters.codecs.push_back(kIsacCodec); |
1855 isac_parameters.codecs.push_back(kCn16000Codec); | 1533 isac_parameters.codecs.push_back(kCn16000Codec); |
1856 isac_parameters.codecs.push_back(kOpusCodec); | 1534 isac_parameters.codecs.push_back(kOpusCodec); |
1857 SetSendParameters(isac_parameters); | 1535 SetSendParameters(isac_parameters); |
1858 { | 1536 { |
1859 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1537 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1860 EXPECT_EQ(103, gcodec.pltype); | 1538 EXPECT_EQ(103, spec.payload_type); |
1861 EXPECT_STREQ("ISAC", gcodec.plname); | 1539 EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str()); |
1862 } | 1540 } |
1863 | 1541 |
1864 SetSendParameters(opus_parameters); | 1542 SetSendParameters(opus_parameters); |
1865 { | 1543 { |
1866 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1544 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1867 EXPECT_EQ(111, gcodec.pltype); | 1545 EXPECT_EQ(111, spec.payload_type); |
1868 EXPECT_STREQ("opus", gcodec.plname); | 1546 EXPECT_STRCASEEQ("opus", spec.format.format.name.c_str()); |
1869 } | 1547 } |
1870 } | 1548 } |
1871 | 1549 |
1872 // Test that we handle various ways of specifying bitrate. | 1550 // Test that we handle various ways of specifying bitrate. |
1873 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1551 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1874 EXPECT_TRUE(SetupSendStream()); | 1552 EXPECT_TRUE(SetupSendStream()); |
1875 cricket::AudioSendParameters parameters; | 1553 cricket::AudioSendParameters parameters; |
1876 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1554 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1877 SetSendParameters(parameters); | 1555 SetSendParameters(parameters); |
1878 { | 1556 { |
1879 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1557 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1880 EXPECT_EQ(103, gcodec.pltype); | 1558 EXPECT_EQ(103, spec.payload_type); |
1881 EXPECT_STREQ("ISAC", gcodec.plname); | 1559 EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str()); |
1882 EXPECT_EQ(32000, gcodec.rate); | 1560 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1883 } | 1561 } |
1884 | 1562 |
1885 parameters.codecs[0].bitrate = 0; // bitrate == default | 1563 parameters.codecs[0].bitrate = 0; // bitrate == default |
1886 SetSendParameters(parameters); | 1564 SetSendParameters(parameters); |
1887 { | 1565 { |
1888 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1566 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1889 EXPECT_EQ(103, gcodec.pltype); | 1567 EXPECT_EQ(103, spec.payload_type); |
1890 EXPECT_STREQ("ISAC", gcodec.plname); | 1568 EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str()); |
1891 EXPECT_EQ(32000, gcodec.rate); | 1569 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1892 } | 1570 } |
1893 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1571 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1894 SetSendParameters(parameters); | 1572 SetSendParameters(parameters); |
1895 { | 1573 { |
1896 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1574 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1897 EXPECT_EQ(103, gcodec.pltype); | 1575 EXPECT_EQ(103, spec.payload_type); |
1898 EXPECT_STREQ("ISAC", gcodec.plname); | 1576 EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str()); |
1899 EXPECT_EQ(28000, gcodec.rate); | 1577 EXPECT_EQ(28000, spec.target_bitrate_bps); |
1900 } | 1578 } |
1901 | 1579 |
1902 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1580 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1903 SetSendParameters(parameters); | 1581 SetSendParameters(parameters); |
1904 { | 1582 { |
1905 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1583 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1906 EXPECT_EQ(0, gcodec.pltype); | 1584 EXPECT_EQ(0, spec.payload_type); |
1907 EXPECT_STREQ("PCMU", gcodec.plname); | 1585 EXPECT_STRCASEEQ("PCMU", spec.format.format.name.c_str()); |
1908 EXPECT_EQ(64000, gcodec.rate); | 1586 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1909 } | 1587 } |
1910 | 1588 |
1911 parameters.codecs[0].bitrate = 0; // bitrate == default | 1589 parameters.codecs[0].bitrate = 0; // bitrate == default |
1912 SetSendParameters(parameters); | 1590 SetSendParameters(parameters); |
1913 { | 1591 { |
1914 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1592 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1915 EXPECT_EQ(0, gcodec.pltype); | 1593 EXPECT_EQ(0, spec.payload_type); |
1916 EXPECT_STREQ("PCMU", gcodec.plname); | 1594 EXPECT_STREQ("PCMU", spec.format.format.name.c_str()); |
1917 EXPECT_EQ(64000, gcodec.rate); | 1595 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1918 } | 1596 } |
1919 | 1597 |
1920 parameters.codecs[0] = kOpusCodec; | 1598 parameters.codecs[0] = kOpusCodec; |
1921 parameters.codecs[0].bitrate = 0; // bitrate == default | 1599 parameters.codecs[0].bitrate = 0; // bitrate == default |
1922 SetSendParameters(parameters); | 1600 SetSendParameters(parameters); |
1923 { | 1601 { |
1924 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1602 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1925 EXPECT_EQ(111, gcodec.pltype); | 1603 EXPECT_EQ(111, spec.payload_type); |
1926 EXPECT_STREQ("opus", gcodec.plname); | 1604 EXPECT_STREQ("opus", spec.format.format.name.c_str()); |
1927 EXPECT_EQ(32000, gcodec.rate); | 1605 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1928 } | 1606 } |
1929 } | 1607 } |
1930 | 1608 |
1609 #if 0 | |
ossu
2017/02/22 10:24:23
I think these should be removed. The encoders that
kwiberg-webrtc
2017/02/22 10:42:06
Acknowledged.
| |
1931 // Test that we could set packet size specified in kCodecParamPTime. | 1610 // Test that we could set packet size specified in kCodecParamPTime. |
1932 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | 1611 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
1933 EXPECT_TRUE(SetupSendStream()); | 1612 EXPECT_TRUE(SetupSendStream()); |
1934 cricket::AudioSendParameters parameters; | 1613 cricket::AudioSendParameters parameters; |
1935 parameters.codecs.push_back(kOpusCodec); | 1614 parameters.codecs.push_back(kOpusCodec); |
1936 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1615 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1937 SetSendParameters(parameters); | 1616 SetSendParameters(parameters); |
1938 EXPECT_EQ(1920, GetCodecPacSize(kSsrc1)); // Opus gets 40ms. | 1617 EXPECT_EQ(1920, GetCodecPacSize(kSsrc1)); // Opus gets 40ms. |
1939 | 1618 |
1940 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | 1619 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
1941 SetSendParameters(parameters); | 1620 SetSendParameters(parameters); |
1942 EXPECT_EQ(480, GetCodecPacSize(kSsrc1)); // Opus gets 10ms. | 1621 EXPECT_EQ(480, GetCodecPacSize(kSsrc1)); // Opus gets 10ms. |
1943 | 1622 |
1944 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | 1623 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
1945 SetSendParameters(parameters); | 1624 SetSendParameters(parameters); |
1946 EXPECT_EQ(2880, GetCodecPacSize(kSsrc1)); // Opus gets 60ms. | 1625 EXPECT_EQ(2880, GetCodecPacSize(kSsrc1)); // Opus gets 60ms. |
1947 | 1626 |
1948 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | 1627 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
1949 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1628 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1950 SetSendParameters(parameters); | 1629 SetSendParameters(parameters); |
1951 EXPECT_EQ(480, GetCodecPacSize( | 1630 EXPECT_EQ(480, GetCodecPacSize( |
1952 kSsrc1)); // Isac gets 30ms as the next smallest value. | 1631 kSsrc1)); // Isac gets 30ms as the next smallest value. |
1953 | 1632 |
1954 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | 1633 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
1955 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | 1634 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
1956 SetSendParameters(parameters); | 1635 SetSendParameters(parameters); |
1957 EXPECT_EQ(640, GetCodecPacSize( | 1636 EXPECT_EQ(640, GetCodecPacSize( |
1958 kSsrc1)); // G722 gets 40ms @16kHz as defined in VoE. | 1637 kSsrc1)); // G722 gets 40ms @16kHz as defined in VoE. |
1959 } | 1638 } |
1639 #endif | |
1960 | 1640 |
1961 // Test that we fail if no codecs are specified. | 1641 // Test that we fail if no codecs are specified. |
1962 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1642 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
1963 EXPECT_TRUE(SetupSendStream()); | 1643 EXPECT_TRUE(SetupSendStream()); |
1964 cricket::AudioSendParameters parameters; | 1644 cricket::AudioSendParameters parameters; |
1965 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1645 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1966 } | 1646 } |
1967 | 1647 |
1968 // Test that we can set send codecs even with telephone-event codec as the first | 1648 // Test that we can set send codecs even with telephone-event codec as the first |
1969 // one on the list. | 1649 // one on the list. |
1970 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1650 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
1971 EXPECT_TRUE(SetupSendStream()); | 1651 EXPECT_TRUE(SetupSendStream()); |
1972 cricket::AudioSendParameters parameters; | 1652 cricket::AudioSendParameters parameters; |
1973 parameters.codecs.push_back(kTelephoneEventCodec1); | 1653 parameters.codecs.push_back(kTelephoneEventCodec1); |
1974 parameters.codecs.push_back(kIsacCodec); | 1654 parameters.codecs.push_back(kIsacCodec); |
1975 parameters.codecs.push_back(kPcmuCodec); | 1655 parameters.codecs.push_back(kPcmuCodec); |
1976 parameters.codecs[0].id = 98; // DTMF | 1656 parameters.codecs[0].id = 98; // DTMF |
1977 parameters.codecs[1].id = 96; | 1657 parameters.codecs[1].id = 96; |
1978 SetSendParameters(parameters); | 1658 SetSendParameters(parameters); |
1979 const auto& gcodec = GetSendStreamConfig(kSsrc1).send_codec_spec.codec_inst; | 1659 const auto& spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
1980 EXPECT_EQ(96, gcodec.pltype); | 1660 EXPECT_EQ(96, spec.payload_type); |
1981 EXPECT_STREQ("ISAC", gcodec.plname); | 1661 EXPECT_STRCASEEQ("ISAC", spec.format.format.name.c_str()); |
1982 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1662 EXPECT_TRUE(channel_->CanInsertDtmf()); |
1983 } | 1663 } |
1984 | 1664 |
1985 // Test that payload type range is limited for telephone-event codec. | 1665 // Test that payload type range is limited for telephone-event codec. |
1986 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1666 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
1987 EXPECT_TRUE(SetupSendStream()); | 1667 EXPECT_TRUE(SetupSendStream()); |
1988 cricket::AudioSendParameters parameters; | 1668 cricket::AudioSendParameters parameters; |
1989 parameters.codecs.push_back(kTelephoneEventCodec2); | 1669 parameters.codecs.push_back(kTelephoneEventCodec2); |
1990 parameters.codecs.push_back(kIsacCodec); | 1670 parameters.codecs.push_back(kIsacCodec); |
1991 parameters.codecs[0].id = 0; // DTMF | 1671 parameters.codecs[0].id = 0; // DTMF |
(...skipping 16 matching lines...) Expand all Loading... | |
2008 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1688 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
2009 EXPECT_TRUE(SetupSendStream()); | 1689 EXPECT_TRUE(SetupSendStream()); |
2010 cricket::AudioSendParameters parameters; | 1690 cricket::AudioSendParameters parameters; |
2011 parameters.codecs.push_back(kCn16000Codec); | 1691 parameters.codecs.push_back(kCn16000Codec); |
2012 parameters.codecs.push_back(kIsacCodec); | 1692 parameters.codecs.push_back(kIsacCodec); |
2013 parameters.codecs.push_back(kPcmuCodec); | 1693 parameters.codecs.push_back(kPcmuCodec); |
2014 parameters.codecs[0].id = 98; // wideband CN | 1694 parameters.codecs[0].id = 98; // wideband CN |
2015 parameters.codecs[1].id = 96; | 1695 parameters.codecs[1].id = 96; |
2016 SetSendParameters(parameters); | 1696 SetSendParameters(parameters); |
2017 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1697 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2018 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1698 EXPECT_EQ(96, send_codec_spec.payload_type); |
2019 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1699 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2020 EXPECT_EQ(98, send_codec_spec.cng_payload_type); | 1700 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
2021 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1701 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2022 } | 1702 } |
2023 | 1703 |
2024 // Test that we set VAD and DTMF types correctly as caller. | 1704 // Test that we set VAD and DTMF types correctly as caller. |
2025 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1705 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
2026 EXPECT_TRUE(SetupSendStream()); | 1706 EXPECT_TRUE(SetupSendStream()); |
2027 cricket::AudioSendParameters parameters; | 1707 cricket::AudioSendParameters parameters; |
2028 parameters.codecs.push_back(kIsacCodec); | 1708 parameters.codecs.push_back(kIsacCodec); |
2029 parameters.codecs.push_back(kPcmuCodec); | 1709 parameters.codecs.push_back(kPcmuCodec); |
2030 // TODO(juberti): cn 32000 | 1710 // TODO(juberti): cn 32000 |
2031 parameters.codecs.push_back(kCn16000Codec); | 1711 parameters.codecs.push_back(kCn16000Codec); |
2032 parameters.codecs.push_back(kCn8000Codec); | 1712 parameters.codecs.push_back(kCn8000Codec); |
2033 parameters.codecs.push_back(kTelephoneEventCodec1); | 1713 parameters.codecs.push_back(kTelephoneEventCodec1); |
2034 parameters.codecs[0].id = 96; | 1714 parameters.codecs[0].id = 96; |
2035 parameters.codecs[2].id = 97; // wideband CN | 1715 parameters.codecs[2].id = 97; // wideband CN |
2036 parameters.codecs[4].id = 98; // DTMF | 1716 parameters.codecs[4].id = 98; // DTMF |
2037 SetSendParameters(parameters); | 1717 SetSendParameters(parameters); |
2038 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1718 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2039 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1719 EXPECT_EQ(96, send_codec_spec.payload_type); |
2040 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1720 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2041 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1721 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); |
2042 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1722 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
1723 send_codec_spec.cng_plfreq); | |
2043 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1724 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2044 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1725 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2045 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1726 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2046 } | 1727 } |
2047 | 1728 |
2048 // Test that we set VAD and DTMF types correctly as callee. | 1729 // Test that we set VAD and DTMF types correctly as callee. |
2049 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1730 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
2050 EXPECT_TRUE(SetupChannel()); | 1731 EXPECT_TRUE(SetupChannel()); |
2051 cricket::AudioSendParameters parameters; | 1732 cricket::AudioSendParameters parameters; |
2052 parameters.codecs.push_back(kIsacCodec); | 1733 parameters.codecs.push_back(kIsacCodec); |
2053 parameters.codecs.push_back(kPcmuCodec); | 1734 parameters.codecs.push_back(kPcmuCodec); |
2054 // TODO(juberti): cn 32000 | 1735 // TODO(juberti): cn 32000 |
2055 parameters.codecs.push_back(kCn16000Codec); | 1736 parameters.codecs.push_back(kCn16000Codec); |
2056 parameters.codecs.push_back(kCn8000Codec); | 1737 parameters.codecs.push_back(kCn8000Codec); |
2057 parameters.codecs.push_back(kTelephoneEventCodec2); | 1738 parameters.codecs.push_back(kTelephoneEventCodec2); |
2058 parameters.codecs[0].id = 96; | 1739 parameters.codecs[0].id = 96; |
2059 parameters.codecs[2].id = 97; // wideband CN | 1740 parameters.codecs[2].id = 97; // wideband CN |
2060 parameters.codecs[4].id = 98; // DTMF | 1741 parameters.codecs[4].id = 98; // DTMF |
2061 SetSendParameters(parameters); | 1742 SetSendParameters(parameters); |
2062 EXPECT_TRUE(channel_->AddSendStream( | 1743 EXPECT_TRUE(channel_->AddSendStream( |
2063 cricket::StreamParams::CreateLegacy(kSsrc1))); | 1744 cricket::StreamParams::CreateLegacy(kSsrc1))); |
2064 | 1745 |
2065 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1746 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2066 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1747 EXPECT_EQ(96, send_codec_spec.payload_type); |
2067 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1748 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2068 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1749 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); |
2069 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1750 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
1751 send_codec_spec.cng_plfreq); | |
2070 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1752 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2071 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1753 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2072 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1754 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2073 } | 1755 } |
2074 | 1756 |
2075 // Test that we only apply VAD if we have a CN codec that matches the | 1757 // Test that we only apply VAD if we have a CN codec that matches the |
2076 // send codec clockrate. | 1758 // send codec clockrate. |
2077 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1759 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
2078 EXPECT_TRUE(SetupSendStream()); | 1760 EXPECT_TRUE(SetupSendStream()); |
2079 cricket::AudioSendParameters parameters; | 1761 cricket::AudioSendParameters parameters; |
2080 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1762 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2081 parameters.codecs.push_back(kIsacCodec); | 1763 parameters.codecs.push_back(kIsacCodec); |
2082 parameters.codecs.push_back(kCn16000Codec); | 1764 parameters.codecs.push_back(kCn16000Codec); |
2083 parameters.codecs[1].id = 97; | 1765 parameters.codecs[1].id = 97; |
2084 SetSendParameters(parameters); | 1766 SetSendParameters(parameters); |
2085 { | 1767 { |
2086 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1768 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2087 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1769 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2088 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1770 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); |
2089 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1771 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
1772 send_codec_spec.cng_plfreq); | |
2090 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1773 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2091 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1774 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2092 } | 1775 } |
2093 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1776 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
2094 parameters.codecs[0] = kPcmuCodec; | 1777 parameters.codecs[0] = kPcmuCodec; |
2095 SetSendParameters(parameters); | 1778 SetSendParameters(parameters); |
2096 { | 1779 { |
2097 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1780 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2098 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1781 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str()); |
2099 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1782 EXPECT_NE(send_codec_spec.format.format.clockrate_hz, |
1783 send_codec_spec.cng_plfreq); | |
2100 } | 1784 } |
2101 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1785 // Set PCMU(8K) and CN(8K). VAD should be activated. |
2102 parameters.codecs[1] = kCn8000Codec; | 1786 parameters.codecs[1] = kCn8000Codec; |
2103 SetSendParameters(parameters); | 1787 SetSendParameters(parameters); |
2104 { | 1788 { |
2105 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1789 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2106 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1790 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str()); |
2107 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1791 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); |
2108 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1792 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
1793 send_codec_spec.cng_plfreq); | |
2109 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1794 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
2110 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | 1795 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
2111 } | 1796 } |
2112 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1797 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
2113 parameters.codecs[0] = kIsacCodec; | 1798 parameters.codecs[0] = kIsacCodec; |
2114 SetSendParameters(parameters); | 1799 SetSendParameters(parameters); |
2115 { | 1800 { |
2116 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1801 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2117 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1802 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2118 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1803 EXPECT_NE(send_codec_spec.format.format.clockrate_hz, |
1804 send_codec_spec.cng_plfreq); | |
2119 } | 1805 } |
2120 } | 1806 } |
2121 | 1807 |
2122 // Test that we perform case-insensitive matching of codec names. | 1808 // Test that we perform case-insensitive matching of codec names. |
2123 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1809 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
2124 EXPECT_TRUE(SetupSendStream()); | 1810 EXPECT_TRUE(SetupSendStream()); |
2125 cricket::AudioSendParameters parameters; | 1811 cricket::AudioSendParameters parameters; |
2126 parameters.codecs.push_back(kIsacCodec); | 1812 parameters.codecs.push_back(kIsacCodec); |
2127 parameters.codecs.push_back(kPcmuCodec); | 1813 parameters.codecs.push_back(kPcmuCodec); |
2128 parameters.codecs.push_back(kCn16000Codec); | 1814 parameters.codecs.push_back(kCn16000Codec); |
2129 parameters.codecs.push_back(kCn8000Codec); | 1815 parameters.codecs.push_back(kCn8000Codec); |
2130 parameters.codecs.push_back(kTelephoneEventCodec1); | 1816 parameters.codecs.push_back(kTelephoneEventCodec1); |
2131 parameters.codecs[0].name = "iSaC"; | 1817 parameters.codecs[0].name = "iSaC"; |
2132 parameters.codecs[0].id = 96; | 1818 parameters.codecs[0].id = 96; |
2133 parameters.codecs[2].id = 97; // wideband CN | 1819 parameters.codecs[2].id = 97; // wideband CN |
2134 parameters.codecs[4].id = 98; // DTMF | 1820 parameters.codecs[4].id = 98; // DTMF |
2135 SetSendParameters(parameters); | 1821 SetSendParameters(parameters); |
2136 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; | 1822 const auto& send_codec_spec = GetSendStreamConfig(kSsrc1).send_codec_spec; |
2137 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1823 EXPECT_EQ(96, send_codec_spec.payload_type); |
2138 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1824 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2139 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1825 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); |
2140 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1826 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
1827 send_codec_spec.cng_plfreq); | |
2141 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1828 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2142 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1829 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2143 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1830 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2144 } | 1831 } |
2145 | 1832 |
2146 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { | 1833 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
2147 public: | 1834 public: |
2148 WebRtcVoiceEngineWithSendSideBweTest() | 1835 WebRtcVoiceEngineWithSendSideBweTest() |
2149 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} | 1836 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
2150 }; | 1837 }; |
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2291 parameters.codecs.push_back(kIsacCodec); | 1978 parameters.codecs.push_back(kIsacCodec); |
2292 parameters.codecs.push_back(kCn16000Codec); | 1979 parameters.codecs.push_back(kCn16000Codec); |
2293 parameters.codecs[1].id = 97; | 1980 parameters.codecs[1].id = 97; |
2294 SetSendParameters(parameters); | 1981 SetSendParameters(parameters); |
2295 | 1982 |
2296 // Verify ISAC and VAD are corrected configured on all send channels. | 1983 // Verify ISAC and VAD are corrected configured on all send channels. |
2297 for (uint32_t ssrc : kSsrcs4) { | 1984 for (uint32_t ssrc : kSsrcs4) { |
2298 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1985 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2299 const auto& send_codec_spec = | 1986 const auto& send_codec_spec = |
2300 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 1987 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2301 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1988 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.format.name.c_str()); |
2302 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1989 EXPECT_EQ(send_codec_spec.format.format.clockrate_hz, |
2303 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1990 send_codec_spec.cng_plfreq); |
1991 EXPECT_EQ(1, send_codec_spec.format.info.num_channels); | |
2304 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1992 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2305 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1993 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2306 } | 1994 } |
2307 | 1995 |
2308 // Change to PCMU(8K) and CN(16K). | 1996 // Change to PCMU(8K) and CN(16K). |
2309 parameters.codecs[0] = kPcmuCodec; | 1997 parameters.codecs[0] = kPcmuCodec; |
2310 SetSendParameters(parameters); | 1998 SetSendParameters(parameters); |
2311 for (uint32_t ssrc : kSsrcs4) { | 1999 for (uint32_t ssrc : kSsrcs4) { |
2312 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 2000 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2313 const auto& send_codec_spec = | 2001 const auto& send_codec_spec = |
2314 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 2002 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2315 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 2003 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.format.name.c_str()); |
2316 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 2004 EXPECT_NE(send_codec_spec.format.format.clockrate_hz, |
2005 send_codec_spec.cng_plfreq); | |
2317 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 2006 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2318 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 2007 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2319 } | 2008 } |
2320 } | 2009 } |
2321 | 2010 |
2322 // Test we can SetSend on all send streams correctly. | 2011 // Test we can SetSend on all send streams correctly. |
2323 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 2012 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2324 SetupForMultiSendStream(); | 2013 SetupForMultiSendStream(); |
2325 | 2014 |
2326 // Create the send channels and they should be a "not sending" date. | 2015 // Create the send channels and they should be a "not sending" date. |
(...skipping 1281 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3608 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); | 3297 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); |
3609 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | 3298 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( |
3610 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); | 3299 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); |
3611 | 3300 |
3612 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. | 3301 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. |
3613 // TODO(ossu): Why are the payload types of codecs with non-static payload | 3302 // TODO(ossu): Why are the payload types of codecs with non-static payload |
3614 // type assignments checked here? It shouldn't really matter. | 3303 // type assignments checked here? It shouldn't really matter. |
3615 cricket::WebRtcVoiceEngine engine( | 3304 cricket::WebRtcVoiceEngine engine( |
3616 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); | 3305 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); |
3617 for (const cricket::AudioCodec& codec : engine.send_codecs()) { | 3306 for (const cricket::AudioCodec& codec : engine.send_codecs()) { |
3618 if (codec.name == "CN" && codec.clockrate == 16000) { | 3307 auto is_codec = [&codec](const char* name, int clockrate = 0) { |
3308 return STR_CASE_CMP(codec.name.c_str(), name) == 0 && | |
3309 (clockrate == 0 || codec.clockrate == clockrate); | |
3310 }; | |
3311 if (is_codec("CN", 16000)) { | |
3619 EXPECT_EQ(105, codec.id); | 3312 EXPECT_EQ(105, codec.id); |
3620 } else if (codec.name == "CN" && codec.clockrate == 32000) { | 3313 } else if (is_codec("CN", 32000)) { |
3621 EXPECT_EQ(106, codec.id); | 3314 EXPECT_EQ(106, codec.id); |
3622 } else if (codec.name == "ISAC" && codec.clockrate == 16000) { | 3315 } else if (is_codec("ISAC", 16000)) { |
3623 EXPECT_EQ(103, codec.id); | 3316 EXPECT_EQ(103, codec.id); |
3624 } else if (codec.name == "ISAC" && codec.clockrate == 32000) { | 3317 } else if (is_codec("ISAC", 32000)) { |
3625 EXPECT_EQ(104, codec.id); | 3318 EXPECT_EQ(104, codec.id); |
3626 } else if (codec.name == "G722" && codec.clockrate == 8000) { | 3319 } else if (is_codec("G722", 8000)) { |
3627 EXPECT_EQ(9, codec.id); | 3320 EXPECT_EQ(9, codec.id); |
3628 } else if (codec.name == "telephone-event" && codec.clockrate == 8000) { | 3321 } else if (is_codec("telephone-event", 8000)) { |
3629 EXPECT_EQ(126, codec.id); | 3322 EXPECT_EQ(126, codec.id); |
3630 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. | 3323 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. |
3631 // Remove these checks once both send and receive side assigns payload types | 3324 // Remove these checks once both send and receive side assigns payload types |
3632 // dynamically. | 3325 // dynamically. |
3633 } else if (codec.name == "telephone-event" && codec.clockrate == 16000) { | 3326 } else if (is_codec("telephone-event", 16000)) { |
3634 EXPECT_EQ(113, codec.id); | 3327 EXPECT_EQ(113, codec.id); |
3635 } else if (codec.name == "telephone-event" && codec.clockrate == 32000) { | 3328 } else if (is_codec("telephone-event", 32000)) { |
3636 EXPECT_EQ(112, codec.id); | 3329 EXPECT_EQ(112, codec.id); |
3637 } else if (codec.name == "telephone-event" && codec.clockrate == 48000) { | 3330 } else if (is_codec("telephone-event", 48000)) { |
3638 EXPECT_EQ(110, codec.id); | 3331 EXPECT_EQ(110, codec.id); |
3639 } else if (codec.name == "opus") { | 3332 } else if (is_codec("opus")) { |
3640 EXPECT_EQ(111, codec.id); | 3333 EXPECT_EQ(111, codec.id); |
3641 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); | 3334 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); |
3642 EXPECT_EQ("10", codec.params.find("minptime")->second); | 3335 EXPECT_EQ("10", codec.params.find("minptime")->second); |
3643 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); | 3336 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); |
3644 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); | 3337 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); |
3645 } | 3338 } |
3646 } | 3339 } |
3647 } | 3340 } |
3648 | 3341 |
3649 // Tests that VoE supports at least 32 channels | 3342 // Tests that VoE supports at least 32 channels |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3761 // Without this cast, the comparison turned unsigned and, thus, failed for -1. | 3454 // Without this cast, the comparison turned unsigned and, thus, failed for -1. |
3762 const int num_specs = static_cast<int>(specs.size()); | 3455 const int num_specs = static_cast<int>(specs.size()); |
3763 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); | 3456 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); |
3764 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); | 3457 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); |
3765 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); | 3458 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); |
3766 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); | 3459 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); |
3767 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); | 3460 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); |
3768 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); | 3461 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); |
3769 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); | 3462 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); |
3770 } | 3463 } |
OLD | NEW |