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 23 matching lines...) Expand all Loading... |
34 using testing::ContainerEq; | 34 using testing::ContainerEq; |
35 using testing::Return; | 35 using testing::Return; |
36 using testing::StrictMock; | 36 using testing::StrictMock; |
37 | 37 |
38 namespace { | 38 namespace { |
39 | 39 |
40 constexpr uint32_t kMaxUnsignaledRecvStreams = 1; | 40 constexpr uint32_t kMaxUnsignaledRecvStreams = 1; |
41 | 41 |
42 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); | 42 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); |
43 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); | 43 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); |
44 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); | 44 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 32000, 2); |
45 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); | 45 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); |
46 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); | 46 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); |
47 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); | 47 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); |
48 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); | 48 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); |
49 const cricket::AudioCodec | 49 const cricket::AudioCodec |
50 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); | 50 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); |
51 const cricket::AudioCodec | 51 const cricket::AudioCodec |
52 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); | 52 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); |
53 | 53 |
54 const uint32_t kSsrc0 = 0; | 54 const uint32_t kSsrc0 = 0; |
(...skipping 300 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
355 return channel_->SetRtpSendParameters(ssrc, parameters); | 355 return channel_->SetRtpSendParameters(ssrc, parameters); |
356 } | 356 } |
357 | 357 |
358 void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { | 358 void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { |
359 cricket::AudioSendParameters send_parameters; | 359 cricket::AudioSendParameters send_parameters; |
360 send_parameters.codecs.push_back(codec); | 360 send_parameters.codecs.push_back(codec); |
361 send_parameters.max_bandwidth_bps = bitrate; | 361 send_parameters.max_bandwidth_bps = bitrate; |
362 SetSendParameters(send_parameters); | 362 SetSendParameters(send_parameters); |
363 } | 363 } |
364 | 364 |
365 void CheckSendCodec(int32_t ssrc, | 365 void CheckSendCodecBitrate(int32_t ssrc, |
366 const char expected_name[], | 366 const char expected_name[], |
367 int expected_channels, | 367 int expected_bitrate) { |
368 int expected_bitrate) { | 368 const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec; |
369 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; | 369 EXPECT_EQ(expected_name, spec->format.name); |
370 EXPECT_STREQ(expected_name, codec.plname); | 370 EXPECT_EQ(expected_bitrate, spec->target_bitrate_bps); |
371 EXPECT_EQ(expected_channels, codec.channels); | |
372 EXPECT_EQ(expected_bitrate, codec.rate); | |
373 } | 371 } |
374 | 372 |
375 int GetOpusMaxPlaybackRate(int32_t ssrc) { | 373 rtc::Optional<int> GetCodecBitrate(int32_t ssrc) { |
376 return GetSendStreamConfig(ssrc).send_codec_spec.opus_max_playback_rate; | 374 return GetSendStreamConfig(ssrc).send_codec_spec->target_bitrate_bps; |
377 } | |
378 | |
379 bool GetOpusDtx(int32_t ssrc) { | |
380 return GetSendStreamConfig(ssrc).send_codec_spec.enable_opus_dtx; | |
381 } | |
382 | |
383 bool GetCodecFec(int32_t ssrc) { | |
384 return GetSendStreamConfig(ssrc).send_codec_spec.enable_codec_fec; | |
385 } | |
386 | |
387 int GetCodecBitrate(int32_t ssrc) { | |
388 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.rate; | |
389 } | |
390 | |
391 int GetCodecPacSize(int32_t ssrc) { | |
392 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.pacsize; | |
393 } | 375 } |
394 | 376 |
395 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { | 377 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { |
396 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; | 378 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; |
397 } | 379 } |
398 | 380 |
399 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, | 381 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
400 int global_max, | 382 int global_max, |
401 int stream_max, | 383 int stream_max, |
402 bool expected_result, | 384 bool expected_result, |
(...skipping 308 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
711 GetRecvStreamConfig(kSsrcX); | 693 GetRecvStreamConfig(kSsrcX); |
712 EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc); | 694 EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc); |
713 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); | 695 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); |
714 EXPECT_FALSE(config.rtp.transport_cc); | 696 EXPECT_FALSE(config.rtp.transport_cc); |
715 EXPECT_EQ(0u, config.rtp.extensions.size()); | 697 EXPECT_EQ(0u, config.rtp.extensions.size()); |
716 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), | 698 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), |
717 config.rtcp_send_transport); | 699 config.rtcp_send_transport); |
718 EXPECT_EQ("", config.sync_group); | 700 EXPECT_EQ("", config.sync_group); |
719 } | 701 } |
720 | 702 |
721 // Tests that the list of supported codecs is created properly and ordered | |
722 // correctly (such that opus appears first). | |
723 // TODO(ossu): This test should move into a separate builtin audio codecs | |
724 // module. | |
725 TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) { | |
726 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | |
727 ASSERT_FALSE(codecs.empty()); | |
728 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); | |
729 EXPECT_EQ(48000, codecs[0].clockrate); | |
730 EXPECT_EQ(2, codecs[0].channels); | |
731 EXPECT_EQ(64000, codecs[0].bitrate); | |
732 } | |
733 | |
734 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { | 703 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { |
735 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | 704 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
736 bool opus_found = false; | 705 bool opus_found = false; |
737 for (cricket::AudioCodec codec : codecs) { | 706 for (cricket::AudioCodec codec : codecs) { |
738 if (codec.name == "opus") { | 707 if (codec.name == "opus") { |
739 EXPECT_TRUE(HasTransportCc(codec)); | 708 EXPECT_TRUE(HasTransportCc(codec)); |
740 opus_found = true; | 709 opus_found = true; |
741 } | 710 } |
742 } | 711 } |
743 EXPECT_TRUE(opus_found); | 712 EXPECT_TRUE(opus_found); |
744 } | 713 } |
745 | 714 |
746 // Tests that we can find codecs by name or id, and that we interpret the | |
747 // clockrate and bitrate fields properly. | |
748 TEST_F(WebRtcVoiceEngineTestFake, FindCodec) { | |
749 cricket::AudioCodec codec; | |
750 webrtc::CodecInst codec_inst; | |
751 // Find PCMU with explicit clockrate and bitrate. | |
752 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst)); | |
753 // Find ISAC with explicit clockrate and 0 bitrate. | |
754 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst)); | |
755 // Find telephone-event with explicit clockrate and 0 bitrate. | |
756 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec1, | |
757 &codec_inst)); | |
758 // Find telephone-event with explicit clockrate and 0 bitrate. | |
759 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec2, | |
760 &codec_inst)); | |
761 // Find ISAC with a different payload id. | |
762 codec = kIsacCodec; | |
763 codec.id = 127; | |
764 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
765 EXPECT_EQ(codec.id, codec_inst.pltype); | |
766 // Find PCMU with a 0 clockrate. | |
767 codec = kPcmuCodec; | |
768 codec.clockrate = 0; | |
769 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
770 EXPECT_EQ(codec.id, codec_inst.pltype); | |
771 EXPECT_EQ(8000, codec_inst.plfreq); | |
772 // Find PCMU with a 0 bitrate. | |
773 codec = kPcmuCodec; | |
774 codec.bitrate = 0; | |
775 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
776 EXPECT_EQ(codec.id, codec_inst.pltype); | |
777 EXPECT_EQ(64000, codec_inst.rate); | |
778 // Find ISAC with an explicit bitrate. | |
779 codec = kIsacCodec; | |
780 codec.bitrate = 32000; | |
781 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
782 EXPECT_EQ(codec.id, codec_inst.pltype); | |
783 EXPECT_EQ(32000, codec_inst.rate); | |
784 } | |
785 | |
786 // Test that we set our inbound codecs properly, including changing PT. | 715 // Test that we set our inbound codecs properly, including changing PT. |
787 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { | 716 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { |
788 EXPECT_TRUE(SetupChannel()); | 717 EXPECT_TRUE(SetupChannel()); |
789 cricket::AudioRecvParameters parameters; | 718 cricket::AudioRecvParameters parameters; |
790 parameters.codecs.push_back(kIsacCodec); | 719 parameters.codecs.push_back(kIsacCodec); |
791 parameters.codecs.push_back(kPcmuCodec); | 720 parameters.codecs.push_back(kPcmuCodec); |
792 parameters.codecs.push_back(kTelephoneEventCodec1); | 721 parameters.codecs.push_back(kTelephoneEventCodec1); |
793 parameters.codecs.push_back(kTelephoneEventCodec2); | 722 parameters.codecs.push_back(kTelephoneEventCodec2); |
794 parameters.codecs[0].id = 106; // collide with existing CN 32k | 723 parameters.codecs[0].id = 106; // collide with existing CN 32k |
795 parameters.codecs[2].id = 126; | 724 parameters.codecs[2].id = 126; |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
927 EXPECT_TRUE(SetupRecvStream()); | 856 EXPECT_TRUE(SetupRecvStream()); |
928 cricket::AudioRecvParameters parameters; | 857 cricket::AudioRecvParameters parameters; |
929 parameters.codecs.push_back(kIsacCodec); | 858 parameters.codecs.push_back(kIsacCodec); |
930 parameters.codecs.push_back(kCn16000Codec); | 859 parameters.codecs.push_back(kCn16000Codec); |
931 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 860 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
932 channel_->SetPlayout(true); | 861 channel_->SetPlayout(true); |
933 | 862 |
934 parameters.codecs.push_back(kOpusCodec); | 863 parameters.codecs.push_back(kOpusCodec); |
935 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 864 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
936 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); | 865 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); |
937 webrtc::CodecInst gcodec; | |
938 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec)); | |
939 EXPECT_EQ(kOpusCodec.id, gcodec.pltype); | |
940 } | 866 } |
941 | 867 |
942 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { | 868 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { |
943 EXPECT_TRUE(SetupSendStream()); | 869 EXPECT_TRUE(SetupSendStream()); |
944 | 870 |
945 // Test that when autobw is enabled, bitrate is kept as the default | 871 // Test that when autobw is enabled, bitrate is kept as the default |
946 // value. autobw is enabled for the following tests because the target | 872 // value. autobw is enabled for the following tests because the target |
947 // bitrate is <= 0. | 873 // bitrate is <= 0. |
948 | 874 |
949 // ISAC, default bitrate == 32000. | 875 // ISAC, default bitrate == 32000. |
950 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); | 876 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); |
951 | 877 |
952 // PCMU, default bitrate == 64000. | 878 // PCMU, default bitrate == 64000. |
953 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); | 879 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); |
954 | 880 |
955 // opus, default bitrate == 64000. | 881 // opus, default bitrate == 32000 in mono. |
956 TestMaxSendBandwidth(kOpusCodec, -1, true, 64000); | 882 TestMaxSendBandwidth(kOpusCodec, -1, true, 32000); |
957 } | 883 } |
958 | 884 |
959 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { | 885 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { |
960 EXPECT_TRUE(SetupSendStream()); | 886 EXPECT_TRUE(SetupSendStream()); |
961 | 887 |
962 // Test that the bitrate of a multi-rate codec is always the maximum. | |
963 | |
964 // ISAC, default bitrate == 32000. | 888 // ISAC, default bitrate == 32000. |
965 TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000); | |
966 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); | 889 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); |
967 // Rates above the max (56000) should be capped. | 890 // Rates above the max (56000) should be capped. |
968 TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000); | 891 TestMaxSendBandwidth(kIsacCodec, 100000, true, 32000); |
969 | 892 |
970 // opus, default bitrate == 64000. | 893 // opus, default bitrate == 64000. |
971 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); | 894 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); |
972 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); | 895 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); |
973 // Rates above the max (510000) should be capped. | 896 // Rates above the max (510000) should be capped. |
974 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); | 897 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); |
975 } | 898 } |
976 | 899 |
977 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { | 900 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { |
978 EXPECT_TRUE(SetupSendStream()); | 901 EXPECT_TRUE(SetupSendStream()); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1021 send_parameters_.max_bandwidth_bps = 128; | 944 send_parameters_.max_bandwidth_bps = 128; |
1022 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); | 945 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
1023 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | 946 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); |
1024 } | 947 } |
1025 | 948 |
1026 // Test that the per-stream bitrate limit and the global | 949 // Test that the per-stream bitrate limit and the global |
1027 // bitrate limit both apply. | 950 // bitrate limit both apply. |
1028 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { | 951 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
1029 EXPECT_TRUE(SetupSendStream()); | 952 EXPECT_TRUE(SetupSendStream()); |
1030 | 953 |
1031 // opus, default bitrate == 64000. | 954 // opus, default bitrate == 32000. |
1032 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); | 955 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000); |
1033 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); | 956 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); |
1034 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); | 957 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); |
1035 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); | 958 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); |
1036 | 959 |
1037 // CBR codecs allow both maximums to exceed the bitrate. | 960 // CBR codecs allow both maximums to exceed the bitrate. |
1038 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); | 961 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); |
1039 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); | 962 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); |
1040 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); | 963 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); |
1041 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); | 964 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); |
1042 | 965 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1107 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { | 1030 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { |
1108 SetupForMultiSendStream(); | 1031 SetupForMultiSendStream(); |
1109 // Create send streams. | 1032 // Create send streams. |
1110 for (uint32_t ssrc : kSsrcs4) { | 1033 for (uint32_t ssrc : kSsrcs4) { |
1111 EXPECT_TRUE( | 1034 EXPECT_TRUE( |
1112 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); | 1035 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); |
1113 } | 1036 } |
1114 // Configure one stream to be limited by the stream config, another to be | 1037 // Configure one stream to be limited by the stream config, another to be |
1115 // limited by the global max, and the third one with no per-stream limit | 1038 // limited by the global max, and the third one with no per-stream limit |
1116 // (still subject to the global limit). | 1039 // (still subject to the global limit). |
1117 SetGlobalMaxBitrate(kOpusCodec, 64000); | 1040 SetGlobalMaxBitrate(kOpusCodec, 32000); |
1118 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); | 1041 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000)); |
1119 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); | 1042 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000)); |
1120 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); | 1043 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); |
1121 | 1044 |
1122 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1045 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1123 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); | 1046 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1])); |
1124 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1047 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1125 | 1048 |
1126 // Remove the global cap; the streams should switch to their respective | 1049 // Remove the global cap; the streams should switch to their respective |
1127 // maximums (or remain unchanged if there was no other limit on them.) | 1050 // maximums (or remain unchanged if there was no other limit on them.) |
1128 SetGlobalMaxBitrate(kOpusCodec, -1); | 1051 SetGlobalMaxBitrate(kOpusCodec, -1); |
1129 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1052 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1130 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); | 1053 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1])); |
1131 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1054 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1132 } | 1055 } |
1133 | 1056 |
1134 // Test that GetRtpSendParameters returns the currently configured codecs. | 1057 // Test that GetRtpSendParameters returns the currently configured codecs. |
1135 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { | 1058 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { |
1136 EXPECT_TRUE(SetupSendStream()); | 1059 EXPECT_TRUE(SetupSendStream()); |
1137 cricket::AudioSendParameters parameters; | 1060 cricket::AudioSendParameters parameters; |
1138 parameters.codecs.push_back(kIsacCodec); | 1061 parameters.codecs.push_back(kIsacCodec); |
1139 parameters.codecs.push_back(kPcmuCodec); | 1062 parameters.codecs.push_back(kPcmuCodec); |
1140 SetSendParameters(parameters); | 1063 SetSendParameters(parameters); |
1141 | 1064 |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1240 | 1163 |
1241 // Test that we apply codecs properly. | 1164 // Test that we apply codecs properly. |
1242 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { | 1165 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
1243 EXPECT_TRUE(SetupSendStream()); | 1166 EXPECT_TRUE(SetupSendStream()); |
1244 cricket::AudioSendParameters parameters; | 1167 cricket::AudioSendParameters parameters; |
1245 parameters.codecs.push_back(kIsacCodec); | 1168 parameters.codecs.push_back(kIsacCodec); |
1246 parameters.codecs.push_back(kPcmuCodec); | 1169 parameters.codecs.push_back(kPcmuCodec); |
1247 parameters.codecs.push_back(kCn8000Codec); | 1170 parameters.codecs.push_back(kCn8000Codec); |
1248 parameters.codecs[0].id = 96; | 1171 parameters.codecs[0].id = 96; |
1249 parameters.codecs[0].bitrate = 48000; | 1172 parameters.codecs[0].bitrate = 48000; |
1250 const int initial_num = call_.GetNumCreatedSendStreams(); | |
1251 SetSendParameters(parameters); | 1173 SetSendParameters(parameters); |
1252 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1174 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1253 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1175 EXPECT_EQ(96, send_codec_spec.payload_type); |
1254 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1176 // EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); |
1255 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); | 1177 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
1256 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1178 EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000); |
1257 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1179 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
1258 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | 1180 // EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1259 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1181 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1260 } | 1182 } |
1261 | 1183 |
1262 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1184 // Test that WebRtcVoiceEngine reconfigures, rather than recreates its |
1263 // to apply. | 1185 // AudioSendStream. |
1264 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1186 TEST_F(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { |
1265 EXPECT_TRUE(SetupSendStream()); | 1187 EXPECT_TRUE(SetupSendStream()); |
1266 cricket::AudioSendParameters parameters; | 1188 cricket::AudioSendParameters parameters; |
1267 parameters.codecs.push_back(kIsacCodec); | 1189 parameters.codecs.push_back(kIsacCodec); |
1268 parameters.codecs.push_back(kPcmuCodec); | 1190 parameters.codecs.push_back(kPcmuCodec); |
1269 parameters.codecs.push_back(kCn8000Codec); | 1191 parameters.codecs.push_back(kCn8000Codec); |
1270 parameters.codecs[0].id = 96; | 1192 parameters.codecs[0].id = 96; |
1271 parameters.codecs[0].bitrate = 48000; | 1193 parameters.codecs[0].bitrate = 48000; |
1272 const int initial_num = call_.GetNumCreatedSendStreams(); | 1194 const int initial_num = call_.GetNumCreatedSendStreams(); |
1273 SetSendParameters(parameters); | 1195 SetSendParameters(parameters); |
1274 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1196 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1275 // Calling SetSendCodec again with same codec which is already set. | 1197 // Calling SetSendCodec again with same codec which is already set. |
1276 // In this case media channel shouldn't send codec to VoE. | 1198 // In this case media channel shouldn't send codec to VoE. |
1277 SetSendParameters(parameters); | 1199 SetSendParameters(parameters); |
1278 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1200 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1279 } | 1201 } |
1280 | 1202 |
1281 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1203 // TODO(ossu): Move these tests into tests for Audio{Encoder,Decoder}Opus or, |
1282 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1204 // possibly, BuiltinAudio{Encoder,Decoder}Factory; this depends on where we move |
1283 EXPECT_TRUE(SetupSendStream()); | 1205 // validation. |
1284 cricket::AudioSendParameters parameters; | |
1285 parameters.codecs.push_back(kG722CodecSdp); | |
1286 SetSendParameters(parameters); | |
1287 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | |
1288 EXPECT_STREQ("G722", gcodec.plname); | |
1289 EXPECT_EQ(1, gcodec.channels); | |
1290 EXPECT_EQ(16000, gcodec.plfreq); | |
1291 } | |
1292 | 1206 |
1293 // Test that if clockrate is not 48000 for opus, we fail. | 1207 // Test that if clockrate is not 48000 for opus, we fail. |
1294 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1208 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1295 EXPECT_TRUE(SetupSendStream()); | 1209 EXPECT_TRUE(SetupSendStream()); |
1296 cricket::AudioSendParameters parameters; | 1210 cricket::AudioSendParameters parameters; |
1297 parameters.codecs.push_back(kOpusCodec); | 1211 parameters.codecs.push_back(kOpusCodec); |
1298 parameters.codecs[0].bitrate = 0; | 1212 parameters.codecs[0].bitrate = 0; |
1299 parameters.codecs[0].clockrate = 50000; | 1213 parameters.codecs[0].clockrate = 50000; |
1300 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1214 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1301 } | 1215 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1346 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { | 1260 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { |
1347 EXPECT_TRUE(SetupSendStream()); | 1261 EXPECT_TRUE(SetupSendStream()); |
1348 cricket::AudioSendParameters parameters; | 1262 cricket::AudioSendParameters parameters; |
1349 parameters.codecs.push_back(kOpusCodec); | 1263 parameters.codecs.push_back(kOpusCodec); |
1350 parameters.codecs[0].bitrate = 0; | 1264 parameters.codecs[0].bitrate = 0; |
1351 parameters.codecs[0].channels = 1; | 1265 parameters.codecs[0].channels = 1; |
1352 parameters.codecs[0].params["stereo"] = "1"; | 1266 parameters.codecs[0].params["stereo"] = "1"; |
1353 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1267 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1354 } | 1268 } |
1355 | 1269 |
1356 // Test that with bitrate=0 and no stereo, | 1270 // Test that with bitrate=0 and no stereo, bitrate is 32000. |
1357 // channels and bitrate are 1 and 32000. | |
1358 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { | 1271 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
1359 EXPECT_TRUE(SetupSendStream()); | 1272 EXPECT_TRUE(SetupSendStream()); |
1360 cricket::AudioSendParameters parameters; | 1273 cricket::AudioSendParameters parameters; |
1361 parameters.codecs.push_back(kOpusCodec); | 1274 parameters.codecs.push_back(kOpusCodec); |
1362 parameters.codecs[0].bitrate = 0; | 1275 parameters.codecs[0].bitrate = 0; |
1363 SetSendParameters(parameters); | 1276 SetSendParameters(parameters); |
1364 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1277 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1365 } | 1278 } |
1366 | 1279 |
1367 // Test that with bitrate=0 and stereo=0, | 1280 // Test that with bitrate=0 and stereo=0, bitrate is 32000. |
1368 // channels and bitrate are 1 and 32000. | |
1369 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { | 1281 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
1370 EXPECT_TRUE(SetupSendStream()); | 1282 EXPECT_TRUE(SetupSendStream()); |
1371 cricket::AudioSendParameters parameters; | 1283 cricket::AudioSendParameters parameters; |
1372 parameters.codecs.push_back(kOpusCodec); | 1284 parameters.codecs.push_back(kOpusCodec); |
1373 parameters.codecs[0].bitrate = 0; | 1285 parameters.codecs[0].bitrate = 0; |
1374 parameters.codecs[0].params["stereo"] = "0"; | 1286 parameters.codecs[0].params["stereo"] = "0"; |
1375 SetSendParameters(parameters); | 1287 SetSendParameters(parameters); |
1376 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1288 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1377 } | 1289 } |
1378 | 1290 |
1379 // Test that with bitrate=invalid and stereo=0, | 1291 // Test that with bitrate=invalid and stereo=0, bitrate is 32000. |
1380 // channels and bitrate are 1 and 32000. | |
1381 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { | 1292 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
1382 EXPECT_TRUE(SetupSendStream()); | 1293 EXPECT_TRUE(SetupSendStream()); |
1383 cricket::AudioSendParameters parameters; | 1294 cricket::AudioSendParameters parameters; |
1384 parameters.codecs.push_back(kOpusCodec); | 1295 parameters.codecs.push_back(kOpusCodec); |
1385 parameters.codecs[0].params["stereo"] = "0"; | 1296 parameters.codecs[0].params["stereo"] = "0"; |
1386 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1297 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1387 parameters.codecs[0].bitrate = 5999; | 1298 parameters.codecs[0].bitrate = 5999; |
1388 SetSendParameters(parameters); | 1299 SetSendParameters(parameters); |
1389 CheckSendCodec(kSsrcX, "opus", 1, 6000); | 1300 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1390 | 1301 |
1391 parameters.codecs[0].bitrate = 510001; | 1302 parameters.codecs[0].bitrate = 510001; |
1392 SetSendParameters(parameters); | 1303 SetSendParameters(parameters); |
1393 CheckSendCodec(kSsrcX, "opus", 1, 510000); | 1304 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1394 } | 1305 } |
1395 | 1306 |
1396 // Test that with bitrate=0 and stereo=1, | 1307 // Test that with bitrate=0 and stereo=1, bitrate is 64000. |
1397 // channels and bitrate are 2 and 64000. | |
1398 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { | 1308 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
1399 EXPECT_TRUE(SetupSendStream()); | 1309 EXPECT_TRUE(SetupSendStream()); |
1400 cricket::AudioSendParameters parameters; | 1310 cricket::AudioSendParameters parameters; |
1401 parameters.codecs.push_back(kOpusCodec); | 1311 parameters.codecs.push_back(kOpusCodec); |
1402 parameters.codecs[0].bitrate = 0; | 1312 parameters.codecs[0].bitrate = 0; |
1403 parameters.codecs[0].params["stereo"] = "1"; | 1313 parameters.codecs[0].params["stereo"] = "1"; |
1404 SetSendParameters(parameters); | 1314 SetSendParameters(parameters); |
1405 CheckSendCodec(kSsrcX, "opus", 2, 64000); | 1315 CheckSendCodecBitrate(kSsrcX, "opus", 64000); |
1406 } | 1316 } |
1407 | 1317 |
1408 // Test that with bitrate=invalid and stereo=1, | 1318 // Test that with bitrate=invalid and stereo=1, bitrate is 64000. |
1409 // channels and bitrate are 2 and 64000. | |
1410 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { | 1319 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
1411 EXPECT_TRUE(SetupSendStream()); | 1320 EXPECT_TRUE(SetupSendStream()); |
1412 cricket::AudioSendParameters parameters; | 1321 cricket::AudioSendParameters parameters; |
1413 parameters.codecs.push_back(kOpusCodec); | 1322 parameters.codecs.push_back(kOpusCodec); |
1414 parameters.codecs[0].params["stereo"] = "1"; | 1323 parameters.codecs[0].params["stereo"] = "1"; |
1415 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1324 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1416 parameters.codecs[0].bitrate = 5999; | 1325 parameters.codecs[0].bitrate = 5999; |
1417 SetSendParameters(parameters); | 1326 SetSendParameters(parameters); |
1418 CheckSendCodec(kSsrcX, "opus", 2, 6000); | 1327 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1419 | 1328 |
1420 parameters.codecs[0].bitrate = 510001; | 1329 parameters.codecs[0].bitrate = 510001; |
1421 SetSendParameters(parameters); | 1330 SetSendParameters(parameters); |
1422 CheckSendCodec(kSsrcX, "opus", 2, 510000); | 1331 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1423 } | 1332 } |
1424 | 1333 |
1425 // Test that with bitrate=N and stereo unset, | 1334 // Test that with bitrate=N and stereo unset, bitrate is N. |
1426 // channels and bitrate are 1 and N. | |
1427 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1335 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1428 EXPECT_TRUE(SetupSendStream()); | 1336 EXPECT_TRUE(SetupSendStream()); |
1429 cricket::AudioSendParameters parameters; | 1337 cricket::AudioSendParameters parameters; |
1430 parameters.codecs.push_back(kOpusCodec); | 1338 parameters.codecs.push_back(kOpusCodec); |
1431 parameters.codecs[0].bitrate = 96000; | 1339 parameters.codecs[0].bitrate = 96000; |
1432 SetSendParameters(parameters); | 1340 SetSendParameters(parameters); |
1433 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1341 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1434 EXPECT_EQ(111, gcodec.pltype); | 1342 EXPECT_EQ(111, spec.payload_type); |
1435 EXPECT_EQ(96000, gcodec.rate); | 1343 EXPECT_EQ(96000, spec.target_bitrate_bps); |
1436 EXPECT_STREQ("opus", gcodec.plname); | 1344 EXPECT_EQ("opus", spec.format.name); |
1437 EXPECT_EQ(1, gcodec.channels); | 1345 EXPECT_EQ(2, spec.format.num_channels); |
1438 EXPECT_EQ(48000, gcodec.plfreq); | 1346 EXPECT_EQ(48000, spec.format.clockrate_hz); |
1439 } | 1347 } |
1440 | 1348 |
1441 // Test that with bitrate=N and stereo=0, | 1349 // Test that with bitrate=N and stereo=0, bitrate is N. |
1442 // channels and bitrate are 1 and N. | |
1443 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1350 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1444 EXPECT_TRUE(SetupSendStream()); | 1351 EXPECT_TRUE(SetupSendStream()); |
1445 cricket::AudioSendParameters parameters; | 1352 cricket::AudioSendParameters parameters; |
1446 parameters.codecs.push_back(kOpusCodec); | 1353 parameters.codecs.push_back(kOpusCodec); |
1447 parameters.codecs[0].bitrate = 30000; | 1354 parameters.codecs[0].bitrate = 30000; |
1448 parameters.codecs[0].params["stereo"] = "0"; | 1355 parameters.codecs[0].params["stereo"] = "0"; |
1449 SetSendParameters(parameters); | 1356 SetSendParameters(parameters); |
1450 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1357 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1451 } | 1358 } |
1452 | 1359 |
1453 // Test that with bitrate=N and without any parameters, | 1360 // Test that with bitrate=N and without any parameters, bitrate is N. |
1454 // channels and bitrate are 1 and N. | |
1455 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { | 1361 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
1456 EXPECT_TRUE(SetupSendStream()); | 1362 EXPECT_TRUE(SetupSendStream()); |
1457 cricket::AudioSendParameters parameters; | 1363 cricket::AudioSendParameters parameters; |
1458 parameters.codecs.push_back(kOpusCodec); | 1364 parameters.codecs.push_back(kOpusCodec); |
1459 parameters.codecs[0].bitrate = 30000; | 1365 parameters.codecs[0].bitrate = 30000; |
1460 SetSendParameters(parameters); | 1366 SetSendParameters(parameters); |
1461 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1367 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1462 } | 1368 } |
1463 | 1369 |
1464 // Test that with bitrate=N and stereo=1, | 1370 // Test that with bitrate=N and stereo=1, bitrate is N. |
1465 // channels and bitrate are 2 and N. | |
1466 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1371 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1467 EXPECT_TRUE(SetupSendStream()); | 1372 EXPECT_TRUE(SetupSendStream()); |
1468 cricket::AudioSendParameters parameters; | 1373 cricket::AudioSendParameters parameters; |
1469 parameters.codecs.push_back(kOpusCodec); | 1374 parameters.codecs.push_back(kOpusCodec); |
1470 parameters.codecs[0].bitrate = 30000; | 1375 parameters.codecs[0].bitrate = 30000; |
1471 parameters.codecs[0].params["stereo"] = "1"; | 1376 parameters.codecs[0].params["stereo"] = "1"; |
1472 SetSendParameters(parameters); | 1377 SetSendParameters(parameters); |
1473 CheckSendCodec(kSsrcX, "opus", 2, 30000); | 1378 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1474 } | |
1475 | |
1476 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | |
1477 // Also test that the "maxaveragebitrate" can't be set to values outside the | |
1478 // range of 6000 and 510000 | |
1479 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | |
1480 EXPECT_TRUE(SetupSendStream()); | |
1481 cricket::AudioSendParameters parameters; | |
1482 parameters.codecs.push_back(kOpusCodec); | |
1483 parameters.codecs[0].bitrate = 30000; | |
1484 // Ignore if less than 6000. | |
1485 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | |
1486 SetSendParameters(parameters); | |
1487 EXPECT_EQ(6000, GetCodecBitrate(kSsrcX)); | |
1488 | |
1489 // Ignore if larger than 510000. | |
1490 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | |
1491 SetSendParameters(parameters); | |
1492 EXPECT_EQ(510000, GetCodecBitrate(kSsrcX)); | |
1493 | |
1494 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | |
1495 SetSendParameters(parameters); | |
1496 EXPECT_EQ(200000, GetCodecBitrate(kSsrcX)); | |
1497 } | 1379 } |
1498 | 1380 |
1499 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { | 1381 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { |
1500 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", | 1382 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
1501 200000); | 1383 200000); |
1502 } | 1384 } |
1503 | 1385 |
1504 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { | 1386 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { |
1505 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); | 1387 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); |
1506 } | 1388 } |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1622 cricket::kParamValueEmpty)); | 1504 cricket::kParamValueEmpty)); |
1623 SetSendParameters(parameters); | 1505 SetSendParameters(parameters); |
1624 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); | 1506 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); |
1625 | 1507 |
1626 EXPECT_TRUE(AddRecvStream(kSsrcY)); | 1508 EXPECT_TRUE(AddRecvStream(kSsrcY)); |
1627 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); | 1509 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); |
1628 EXPECT_TRUE(AddRecvStream(kSsrcZ)); | 1510 EXPECT_TRUE(AddRecvStream(kSsrcZ)); |
1629 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); | 1511 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); |
1630 } | 1512 } |
1631 | 1513 |
1632 // Test that without useinbandfec, Opus FEC is off. | |
1633 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | |
1634 EXPECT_TRUE(SetupSendStream()); | |
1635 cricket::AudioSendParameters parameters; | |
1636 parameters.codecs.push_back(kOpusCodec); | |
1637 SetSendParameters(parameters); | |
1638 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1639 } | |
1640 | |
1641 // Test that with useinbandfec=0, Opus FEC is off. | |
1642 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | |
1643 EXPECT_TRUE(SetupSendStream()); | |
1644 cricket::AudioSendParameters parameters; | |
1645 parameters.codecs.push_back(kOpusCodec); | |
1646 parameters.codecs[0].bitrate = 0; | |
1647 parameters.codecs[0].params["useinbandfec"] = "0"; | |
1648 SetSendParameters(parameters); | |
1649 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1650 } | |
1651 | |
1652 // Test that with useinbandfec=1, Opus FEC is on. | |
1653 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | |
1654 EXPECT_TRUE(SetupSendStream()); | |
1655 cricket::AudioSendParameters parameters; | |
1656 parameters.codecs.push_back(kOpusCodec); | |
1657 parameters.codecs[0].bitrate = 0; | |
1658 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1659 SetSendParameters(parameters); | |
1660 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1661 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1662 } | |
1663 | |
1664 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | |
1665 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | |
1666 EXPECT_TRUE(SetupSendStream()); | |
1667 cricket::AudioSendParameters parameters; | |
1668 parameters.codecs.push_back(kOpusCodec); | |
1669 parameters.codecs[0].bitrate = 0; | |
1670 parameters.codecs[0].params["stereo"] = "1"; | |
1671 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1672 SetSendParameters(parameters); | |
1673 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1674 CheckSendCodec(kSsrcX, "opus", 2, 64000); | |
1675 } | |
1676 | |
1677 // Test that with non-Opus, codec FEC is off. | |
1678 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | |
1679 EXPECT_TRUE(SetupSendStream()); | |
1680 cricket::AudioSendParameters parameters; | |
1681 parameters.codecs.push_back(kIsacCodec); | |
1682 SetSendParameters(parameters); | |
1683 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1684 } | |
1685 | |
1686 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | |
1687 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | |
1688 EXPECT_TRUE(SetupSendStream()); | |
1689 cricket::AudioSendParameters parameters; | |
1690 parameters.codecs.push_back(kIsacCodec); | |
1691 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1692 SetSendParameters(parameters); | |
1693 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1694 } | |
1695 | |
1696 // Test that Opus FEC status can be changed. | |
1697 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | |
1698 EXPECT_TRUE(SetupSendStream()); | |
1699 cricket::AudioSendParameters parameters; | |
1700 parameters.codecs.push_back(kOpusCodec); | |
1701 SetSendParameters(parameters); | |
1702 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1703 | |
1704 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1705 SetSendParameters(parameters); | |
1706 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1707 } | |
1708 | |
1709 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1514 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1710 EXPECT_TRUE(SetupChannel()); | 1515 EXPECT_TRUE(SetupChannel()); |
1711 cricket::AudioSendParameters send_parameters; | 1516 cricket::AudioSendParameters send_parameters; |
1712 send_parameters.codecs.push_back(kOpusCodec); | 1517 send_parameters.codecs.push_back(kOpusCodec); |
1713 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1518 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1714 SetSendParameters(send_parameters); | 1519 SetSendParameters(send_parameters); |
1715 | 1520 |
1716 cricket::AudioRecvParameters recv_parameters; | 1521 cricket::AudioRecvParameters recv_parameters; |
1717 recv_parameters.codecs.push_back(kIsacCodec); | 1522 recv_parameters.codecs.push_back(kIsacCodec); |
1718 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1523 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1719 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 1524 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
1720 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1525 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1721 EXPECT_FALSE( | 1526 EXPECT_FALSE( |
1722 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1527 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1723 | 1528 |
1724 send_parameters.codecs = engine_->send_codecs(); | 1529 send_parameters.codecs = engine_->send_codecs(); |
1725 SetSendParameters(send_parameters); | 1530 SetSendParameters(send_parameters); |
1726 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1531 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1727 EXPECT_TRUE( | 1532 EXPECT_TRUE( |
1728 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1533 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1729 } | 1534 } |
1730 | 1535 |
1731 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | |
1732 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | |
1733 EXPECT_TRUE(SetupSendStream()); | |
1734 cricket::AudioSendParameters parameters; | |
1735 parameters.codecs.push_back(kOpusCodec); | |
1736 parameters.codecs[0].bitrate = 0; | |
1737 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1738 SetSendParameters(parameters); | |
1739 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1740 EXPECT_EQ(12000, GetCodecBitrate(kSsrcX)); | |
1741 | |
1742 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1743 SetSendParameters(parameters); | |
1744 EXPECT_EQ(24000, GetCodecBitrate(kSsrcX)); | |
1745 } | |
1746 | |
1747 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | |
1748 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | |
1749 EXPECT_TRUE(SetupSendStream()); | |
1750 cricket::AudioSendParameters parameters; | |
1751 parameters.codecs.push_back(kOpusCodec); | |
1752 parameters.codecs[0].bitrate = 0; | |
1753 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | |
1754 SetSendParameters(parameters); | |
1755 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1756 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1757 | |
1758 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1759 SetSendParameters(parameters); | |
1760 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1761 } | |
1762 | |
1763 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | |
1764 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | |
1765 EXPECT_TRUE(SetupSendStream()); | |
1766 cricket::AudioSendParameters parameters; | |
1767 parameters.codecs.push_back(kOpusCodec); | |
1768 parameters.codecs[0].bitrate = 0; | |
1769 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | |
1770 SetSendParameters(parameters); | |
1771 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1772 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1773 | |
1774 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1775 SetSendParameters(parameters); | |
1776 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1777 } | |
1778 | |
1779 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | |
1780 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | |
1781 EXPECT_TRUE(SetupSendStream()); | |
1782 cricket::AudioSendParameters parameters; | |
1783 parameters.codecs.push_back(kOpusCodec); | |
1784 parameters.codecs[0].bitrate = 0; | |
1785 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | |
1786 SetSendParameters(parameters); | |
1787 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1788 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1789 | |
1790 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1791 SetSendParameters(parameters); | |
1792 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1793 } | |
1794 | |
1795 // Test 24000 < maxplaybackrate triggers Opus full band mode. | |
1796 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | |
1797 EXPECT_TRUE(SetupSendStream()); | |
1798 cricket::AudioSendParameters parameters; | |
1799 parameters.codecs.push_back(kOpusCodec); | |
1800 parameters.codecs[0].bitrate = 0; | |
1801 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | |
1802 SetSendParameters(parameters); | |
1803 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1804 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1805 | |
1806 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1807 SetSendParameters(parameters); | |
1808 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1809 } | |
1810 | |
1811 // Test Opus that without maxplaybackrate, default playback rate is used. | |
1812 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | |
1813 EXPECT_TRUE(SetupSendStream()); | |
1814 cricket::AudioSendParameters parameters; | |
1815 parameters.codecs.push_back(kOpusCodec); | |
1816 SetSendParameters(parameters); | |
1817 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1818 } | |
1819 | |
1820 // Test the with non-Opus, maxplaybackrate has no effect. | |
1821 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | |
1822 EXPECT_TRUE(SetupSendStream()); | |
1823 cricket::AudioSendParameters parameters; | |
1824 parameters.codecs.push_back(kIsacCodec); | |
1825 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | |
1826 SetSendParameters(parameters); | |
1827 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrcX)); | |
1828 } | |
1829 | |
1830 // Test maxplaybackrate can be set on two streams. | |
1831 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | |
1832 EXPECT_TRUE(SetupSendStream()); | |
1833 cricket::AudioSendParameters parameters; | |
1834 parameters.codecs.push_back(kOpusCodec); | |
1835 SetSendParameters(parameters); | |
1836 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1837 | |
1838 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1839 SetSendParameters(parameters); | |
1840 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1841 | |
1842 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcY)); | |
1843 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcY)); | |
1844 } | |
1845 | |
1846 // Test that with usedtx=0, Opus DTX is off. | |
1847 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | |
1848 EXPECT_TRUE(SetupSendStream()); | |
1849 cricket::AudioSendParameters parameters; | |
1850 parameters.codecs.push_back(kOpusCodec); | |
1851 parameters.codecs[0].params["usedtx"] = "0"; | |
1852 SetSendParameters(parameters); | |
1853 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1854 } | |
1855 | |
1856 // Test that with usedtx=1, Opus DTX is on. | |
1857 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | |
1858 EXPECT_TRUE(SetupSendStream()); | |
1859 cricket::AudioSendParameters parameters; | |
1860 parameters.codecs.push_back(kOpusCodec); | |
1861 parameters.codecs[0].params["usedtx"] = "1"; | |
1862 SetSendParameters(parameters); | |
1863 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1864 } | |
1865 | |
1866 // Test that usedtx=1 works with stereo Opus. | |
1867 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | |
1868 EXPECT_TRUE(SetupSendStream()); | |
1869 cricket::AudioSendParameters parameters; | |
1870 parameters.codecs.push_back(kOpusCodec); | |
1871 parameters.codecs[0].params["usedtx"] = "1"; | |
1872 parameters.codecs[0].params["stereo"] = "1"; | |
1873 SetSendParameters(parameters); | |
1874 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1875 } | |
1876 | |
1877 // Test that usedtx=1 does not work with non Opus. | |
1878 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | |
1879 EXPECT_TRUE(SetupSendStream()); | |
1880 cricket::AudioSendParameters parameters; | |
1881 parameters.codecs.push_back(kIsacCodec); | |
1882 parameters.codecs[0].params["usedtx"] = "1"; | |
1883 SetSendParameters(parameters); | |
1884 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1885 } | |
1886 | |
1887 // Test that we can switch back and forth between Opus and ISAC with CN. | 1536 // Test that we can switch back and forth between Opus and ISAC with CN. |
1888 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1537 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1889 EXPECT_TRUE(SetupSendStream()); | 1538 EXPECT_TRUE(SetupSendStream()); |
1890 | 1539 |
1891 cricket::AudioSendParameters opus_parameters; | 1540 cricket::AudioSendParameters opus_parameters; |
1892 opus_parameters.codecs.push_back(kOpusCodec); | 1541 opus_parameters.codecs.push_back(kOpusCodec); |
1893 SetSendParameters(opus_parameters); | 1542 SetSendParameters(opus_parameters); |
1894 { | 1543 { |
1895 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1544 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1896 EXPECT_EQ(111, gcodec.pltype); | 1545 EXPECT_EQ(111, spec.payload_type); |
1897 EXPECT_STREQ("opus", gcodec.plname); | 1546 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1898 } | 1547 } |
1899 | 1548 |
1900 cricket::AudioSendParameters isac_parameters; | 1549 cricket::AudioSendParameters isac_parameters; |
1901 isac_parameters.codecs.push_back(kIsacCodec); | 1550 isac_parameters.codecs.push_back(kIsacCodec); |
1902 isac_parameters.codecs.push_back(kCn16000Codec); | 1551 isac_parameters.codecs.push_back(kCn16000Codec); |
1903 isac_parameters.codecs.push_back(kOpusCodec); | 1552 isac_parameters.codecs.push_back(kOpusCodec); |
1904 SetSendParameters(isac_parameters); | 1553 SetSendParameters(isac_parameters); |
1905 { | 1554 { |
1906 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1555 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1907 EXPECT_EQ(103, gcodec.pltype); | 1556 EXPECT_EQ(103, spec.payload_type); |
1908 EXPECT_STREQ("ISAC", gcodec.plname); | 1557 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1909 } | 1558 } |
1910 | 1559 |
1911 SetSendParameters(opus_parameters); | 1560 SetSendParameters(opus_parameters); |
1912 { | 1561 { |
1913 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1562 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1914 EXPECT_EQ(111, gcodec.pltype); | 1563 EXPECT_EQ(111, spec.payload_type); |
1915 EXPECT_STREQ("opus", gcodec.plname); | 1564 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1916 } | 1565 } |
1917 } | 1566 } |
1918 | 1567 |
1919 // Test that we handle various ways of specifying bitrate. | 1568 // Test that we handle various ways of specifying bitrate. |
1920 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1569 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1921 EXPECT_TRUE(SetupSendStream()); | 1570 EXPECT_TRUE(SetupSendStream()); |
1922 cricket::AudioSendParameters parameters; | 1571 cricket::AudioSendParameters parameters; |
1923 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1572 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1924 SetSendParameters(parameters); | 1573 SetSendParameters(parameters); |
1925 { | 1574 { |
1926 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1575 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1927 EXPECT_EQ(103, gcodec.pltype); | 1576 EXPECT_EQ(103, spec.payload_type); |
1928 EXPECT_STREQ("ISAC", gcodec.plname); | 1577 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1929 EXPECT_EQ(32000, gcodec.rate); | 1578 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1930 } | 1579 } |
1931 | 1580 |
1932 parameters.codecs[0].bitrate = 0; // bitrate == default | 1581 parameters.codecs[0].bitrate = 0; // bitrate == default |
1933 SetSendParameters(parameters); | 1582 SetSendParameters(parameters); |
1934 { | 1583 { |
1935 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1584 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1936 EXPECT_EQ(103, gcodec.pltype); | 1585 EXPECT_EQ(103, spec.payload_type); |
1937 EXPECT_STREQ("ISAC", gcodec.plname); | 1586 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1938 EXPECT_EQ(32000, gcodec.rate); | 1587 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1939 } | 1588 } |
1940 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1589 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1941 SetSendParameters(parameters); | 1590 SetSendParameters(parameters); |
1942 { | 1591 { |
1943 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1592 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1944 EXPECT_EQ(103, gcodec.pltype); | 1593 EXPECT_EQ(103, spec.payload_type); |
1945 EXPECT_STREQ("ISAC", gcodec.plname); | 1594 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1946 EXPECT_EQ(28000, gcodec.rate); | 1595 EXPECT_EQ(28000, spec.target_bitrate_bps); |
1947 } | 1596 } |
1948 | 1597 |
1949 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1598 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1950 SetSendParameters(parameters); | 1599 SetSendParameters(parameters); |
1951 { | 1600 { |
1952 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1601 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1953 EXPECT_EQ(0, gcodec.pltype); | 1602 EXPECT_EQ(0, spec.payload_type); |
1954 EXPECT_STREQ("PCMU", gcodec.plname); | 1603 EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); |
1955 EXPECT_EQ(64000, gcodec.rate); | 1604 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1956 } | 1605 } |
1957 | 1606 |
1958 parameters.codecs[0].bitrate = 0; // bitrate == default | 1607 parameters.codecs[0].bitrate = 0; // bitrate == default |
1959 SetSendParameters(parameters); | 1608 SetSendParameters(parameters); |
1960 { | 1609 { |
1961 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1610 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1962 EXPECT_EQ(0, gcodec.pltype); | 1611 EXPECT_EQ(0, spec.payload_type); |
1963 EXPECT_STREQ("PCMU", gcodec.plname); | 1612 EXPECT_STREQ("PCMU", spec.format.name.c_str()); |
1964 EXPECT_EQ(64000, gcodec.rate); | 1613 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1965 } | 1614 } |
1966 | 1615 |
1967 parameters.codecs[0] = kOpusCodec; | 1616 parameters.codecs[0] = kOpusCodec; |
1968 parameters.codecs[0].bitrate = 0; // bitrate == default | 1617 parameters.codecs[0].bitrate = 0; // bitrate == default |
1969 SetSendParameters(parameters); | 1618 SetSendParameters(parameters); |
1970 { | 1619 { |
1971 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1620 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1972 EXPECT_EQ(111, gcodec.pltype); | 1621 EXPECT_EQ(111, spec.payload_type); |
1973 EXPECT_STREQ("opus", gcodec.plname); | 1622 EXPECT_STREQ("opus", spec.format.name.c_str()); |
1974 EXPECT_EQ(32000, gcodec.rate); | 1623 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1975 } | 1624 } |
1976 } | 1625 } |
1977 | 1626 |
| 1627 #if 0 |
1978 // Test that we could set packet size specified in kCodecParamPTime. | 1628 // Test that we could set packet size specified in kCodecParamPTime. |
1979 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | 1629 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
1980 EXPECT_TRUE(SetupSendStream()); | 1630 EXPECT_TRUE(SetupSendStream()); |
1981 cricket::AudioSendParameters parameters; | 1631 cricket::AudioSendParameters parameters; |
1982 parameters.codecs.push_back(kOpusCodec); | 1632 parameters.codecs.push_back(kOpusCodec); |
1983 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1633 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1984 SetSendParameters(parameters); | 1634 SetSendParameters(parameters); |
1985 EXPECT_EQ(1920, GetCodecPacSize(kSsrcX)); // Opus gets 40ms. | 1635 EXPECT_EQ(1920, GetCodecPacSize(kSsrcX)); // Opus gets 40ms. |
1986 | 1636 |
1987 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | 1637 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
1988 SetSendParameters(parameters); | 1638 SetSendParameters(parameters); |
1989 EXPECT_EQ(480, GetCodecPacSize(kSsrcX)); // Opus gets 10ms. | 1639 EXPECT_EQ(480, GetCodecPacSize(kSsrcX)); // Opus gets 10ms. |
1990 | 1640 |
1991 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | 1641 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
1992 SetSendParameters(parameters); | 1642 SetSendParameters(parameters); |
1993 EXPECT_EQ(2880, GetCodecPacSize(kSsrcX)); // Opus gets 60ms. | 1643 EXPECT_EQ(2880, GetCodecPacSize(kSsrcX)); // Opus gets 60ms. |
1994 | 1644 |
1995 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | 1645 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
1996 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1646 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1997 SetSendParameters(parameters); | 1647 SetSendParameters(parameters); |
1998 EXPECT_EQ(480, GetCodecPacSize( | 1648 EXPECT_EQ(480, GetCodecPacSize( |
1999 kSsrcX)); // Isac gets 30ms as the next smallest value. | 1649 kSsrcX)); // Isac gets 30ms as the next smallest value. |
2000 | 1650 |
2001 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | 1651 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
2002 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | 1652 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
2003 SetSendParameters(parameters); | 1653 SetSendParameters(parameters); |
2004 EXPECT_EQ(640, GetCodecPacSize( | 1654 EXPECT_EQ(640, GetCodecPacSize( |
2005 kSsrcX)); // G722 gets 40ms @16kHz as defined in VoE. | 1655 kSsrcX)); // G722 gets 40ms @16kHz as defined in VoE. |
2006 } | 1656 } |
| 1657 #endif |
2007 | 1658 |
2008 // Test that we fail if no codecs are specified. | 1659 // Test that we fail if no codecs are specified. |
2009 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1660 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
2010 EXPECT_TRUE(SetupSendStream()); | 1661 EXPECT_TRUE(SetupSendStream()); |
2011 cricket::AudioSendParameters parameters; | 1662 cricket::AudioSendParameters parameters; |
2012 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1663 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
2013 } | 1664 } |
2014 | 1665 |
2015 // Test that we can set send codecs even with telephone-event codec as the first | 1666 // Test that we can set send codecs even with telephone-event codec as the first |
2016 // one on the list. | 1667 // one on the list. |
2017 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1668 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
2018 EXPECT_TRUE(SetupSendStream()); | 1669 EXPECT_TRUE(SetupSendStream()); |
2019 cricket::AudioSendParameters parameters; | 1670 cricket::AudioSendParameters parameters; |
2020 parameters.codecs.push_back(kTelephoneEventCodec1); | 1671 parameters.codecs.push_back(kTelephoneEventCodec1); |
2021 parameters.codecs.push_back(kIsacCodec); | 1672 parameters.codecs.push_back(kIsacCodec); |
2022 parameters.codecs.push_back(kPcmuCodec); | 1673 parameters.codecs.push_back(kPcmuCodec); |
2023 parameters.codecs[0].id = 98; // DTMF | 1674 parameters.codecs[0].id = 98; // DTMF |
2024 parameters.codecs[1].id = 96; | 1675 parameters.codecs[1].id = 96; |
2025 SetSendParameters(parameters); | 1676 SetSendParameters(parameters); |
2026 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1677 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2027 EXPECT_EQ(96, gcodec.pltype); | 1678 EXPECT_EQ(96, spec.payload_type); |
2028 EXPECT_STREQ("ISAC", gcodec.plname); | 1679 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
2029 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1680 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2030 } | 1681 } |
2031 | 1682 |
2032 // Test that payload type range is limited for telephone-event codec. | 1683 // Test that payload type range is limited for telephone-event codec. |
2033 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1684 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
2034 EXPECT_TRUE(SetupSendStream()); | 1685 EXPECT_TRUE(SetupSendStream()); |
2035 cricket::AudioSendParameters parameters; | 1686 cricket::AudioSendParameters parameters; |
2036 parameters.codecs.push_back(kTelephoneEventCodec2); | 1687 parameters.codecs.push_back(kTelephoneEventCodec2); |
2037 parameters.codecs.push_back(kIsacCodec); | 1688 parameters.codecs.push_back(kIsacCodec); |
2038 parameters.codecs[0].id = 0; // DTMF | 1689 parameters.codecs[0].id = 0; // DTMF |
(...skipping 15 matching lines...) Expand all Loading... |
2054 // one on the list. | 1705 // one on the list. |
2055 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1706 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
2056 EXPECT_TRUE(SetupSendStream()); | 1707 EXPECT_TRUE(SetupSendStream()); |
2057 cricket::AudioSendParameters parameters; | 1708 cricket::AudioSendParameters parameters; |
2058 parameters.codecs.push_back(kCn16000Codec); | 1709 parameters.codecs.push_back(kCn16000Codec); |
2059 parameters.codecs.push_back(kIsacCodec); | 1710 parameters.codecs.push_back(kIsacCodec); |
2060 parameters.codecs.push_back(kPcmuCodec); | 1711 parameters.codecs.push_back(kPcmuCodec); |
2061 parameters.codecs[0].id = 98; // wideband CN | 1712 parameters.codecs[0].id = 98; // wideband CN |
2062 parameters.codecs[1].id = 96; | 1713 parameters.codecs[1].id = 96; |
2063 SetSendParameters(parameters); | 1714 SetSendParameters(parameters); |
2064 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1715 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2065 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1716 EXPECT_EQ(96, send_codec_spec.payload_type); |
2066 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1717 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2067 EXPECT_EQ(98, send_codec_spec.cng_payload_type); | 1718 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
2068 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1719 // EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2069 } | 1720 } |
2070 | 1721 |
2071 // Test that we set VAD and DTMF types correctly as caller. | 1722 // Test that we set VAD and DTMF types correctly as caller. |
2072 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1723 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
2073 EXPECT_TRUE(SetupSendStream()); | 1724 EXPECT_TRUE(SetupSendStream()); |
2074 cricket::AudioSendParameters parameters; | 1725 cricket::AudioSendParameters parameters; |
2075 parameters.codecs.push_back(kIsacCodec); | 1726 parameters.codecs.push_back(kIsacCodec); |
2076 parameters.codecs.push_back(kPcmuCodec); | 1727 parameters.codecs.push_back(kPcmuCodec); |
2077 // TODO(juberti): cn 32000 | 1728 // TODO(juberti): cn 32000 |
2078 parameters.codecs.push_back(kCn16000Codec); | 1729 parameters.codecs.push_back(kCn16000Codec); |
2079 parameters.codecs.push_back(kCn8000Codec); | 1730 parameters.codecs.push_back(kCn8000Codec); |
2080 parameters.codecs.push_back(kTelephoneEventCodec1); | 1731 parameters.codecs.push_back(kTelephoneEventCodec1); |
2081 parameters.codecs[0].id = 96; | 1732 parameters.codecs[0].id = 96; |
2082 parameters.codecs[2].id = 97; // wideband CN | 1733 parameters.codecs[2].id = 97; // wideband CN |
2083 parameters.codecs[4].id = 98; // DTMF | 1734 parameters.codecs[4].id = 98; // DTMF |
2084 SetSendParameters(parameters); | 1735 SetSendParameters(parameters); |
2085 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1736 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2086 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1737 EXPECT_EQ(96, send_codec_spec.payload_type); |
2087 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1738 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2088 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1739 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2089 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2090 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1740 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2091 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2092 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1741 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2093 } | 1742 } |
2094 | 1743 |
2095 // Test that we set VAD and DTMF types correctly as callee. | 1744 // Test that we set VAD and DTMF types correctly as callee. |
2096 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1745 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
2097 EXPECT_TRUE(SetupChannel()); | 1746 EXPECT_TRUE(SetupChannel()); |
2098 cricket::AudioSendParameters parameters; | 1747 cricket::AudioSendParameters parameters; |
2099 parameters.codecs.push_back(kIsacCodec); | 1748 parameters.codecs.push_back(kIsacCodec); |
2100 parameters.codecs.push_back(kPcmuCodec); | 1749 parameters.codecs.push_back(kPcmuCodec); |
2101 // TODO(juberti): cn 32000 | 1750 // TODO(juberti): cn 32000 |
2102 parameters.codecs.push_back(kCn16000Codec); | 1751 parameters.codecs.push_back(kCn16000Codec); |
2103 parameters.codecs.push_back(kCn8000Codec); | 1752 parameters.codecs.push_back(kCn8000Codec); |
2104 parameters.codecs.push_back(kTelephoneEventCodec2); | 1753 parameters.codecs.push_back(kTelephoneEventCodec2); |
2105 parameters.codecs[0].id = 96; | 1754 parameters.codecs[0].id = 96; |
2106 parameters.codecs[2].id = 97; // wideband CN | 1755 parameters.codecs[2].id = 97; // wideband CN |
2107 parameters.codecs[4].id = 98; // DTMF | 1756 parameters.codecs[4].id = 98; // DTMF |
2108 SetSendParameters(parameters); | 1757 SetSendParameters(parameters); |
2109 EXPECT_TRUE(channel_->AddSendStream( | 1758 EXPECT_TRUE(channel_->AddSendStream( |
2110 cricket::StreamParams::CreateLegacy(kSsrcX))); | 1759 cricket::StreamParams::CreateLegacy(kSsrcX))); |
2111 | 1760 |
2112 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1761 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2113 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1762 EXPECT_EQ(96, send_codec_spec.payload_type); |
2114 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1763 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2115 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1764 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2116 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2117 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1765 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2118 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2119 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1766 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2120 } | 1767 } |
2121 | 1768 |
2122 // Test that we only apply VAD if we have a CN codec that matches the | 1769 // Test that we only apply VAD if we have a CN codec that matches the |
2123 // send codec clockrate. | 1770 // send codec clockrate. |
2124 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1771 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
2125 EXPECT_TRUE(SetupSendStream()); | 1772 EXPECT_TRUE(SetupSendStream()); |
2126 cricket::AudioSendParameters parameters; | 1773 cricket::AudioSendParameters parameters; |
2127 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1774 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2128 parameters.codecs.push_back(kIsacCodec); | 1775 parameters.codecs.push_back(kIsacCodec); |
2129 parameters.codecs.push_back(kCn16000Codec); | 1776 parameters.codecs.push_back(kCn16000Codec); |
2130 parameters.codecs[1].id = 97; | 1777 parameters.codecs[1].id = 97; |
2131 SetSendParameters(parameters); | 1778 SetSendParameters(parameters); |
2132 { | 1779 { |
2133 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1780 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2134 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1781 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2135 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1782 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2136 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2137 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1783 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2138 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2139 } | 1784 } |
2140 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1785 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
2141 parameters.codecs[0] = kPcmuCodec; | 1786 parameters.codecs[0] = kPcmuCodec; |
2142 SetSendParameters(parameters); | 1787 SetSendParameters(parameters); |
2143 { | 1788 { |
2144 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1789 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2145 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1790 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2146 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1791 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2147 } | 1792 } |
2148 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1793 // Set PCMU(8K) and CN(8K). VAD should be activated. |
2149 parameters.codecs[1] = kCn8000Codec; | 1794 parameters.codecs[1] = kCn8000Codec; |
2150 SetSendParameters(parameters); | 1795 SetSendParameters(parameters); |
2151 { | 1796 { |
2152 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1797 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2153 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1798 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2154 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1799 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2155 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2156 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1800 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
2157 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | |
2158 } | 1801 } |
2159 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1802 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
2160 parameters.codecs[0] = kIsacCodec; | 1803 parameters.codecs[0] = kIsacCodec; |
2161 SetSendParameters(parameters); | 1804 SetSendParameters(parameters); |
2162 { | 1805 { |
2163 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1806 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2164 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1807 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2165 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1808 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2166 } | 1809 } |
2167 } | 1810 } |
2168 | 1811 |
2169 // Test that we perform case-insensitive matching of codec names. | 1812 // Test that we perform case-insensitive matching of codec names. |
2170 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1813 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
2171 EXPECT_TRUE(SetupSendStream()); | 1814 EXPECT_TRUE(SetupSendStream()); |
2172 cricket::AudioSendParameters parameters; | 1815 cricket::AudioSendParameters parameters; |
2173 parameters.codecs.push_back(kIsacCodec); | 1816 parameters.codecs.push_back(kIsacCodec); |
2174 parameters.codecs.push_back(kPcmuCodec); | 1817 parameters.codecs.push_back(kPcmuCodec); |
2175 parameters.codecs.push_back(kCn16000Codec); | 1818 parameters.codecs.push_back(kCn16000Codec); |
2176 parameters.codecs.push_back(kCn8000Codec); | 1819 parameters.codecs.push_back(kCn8000Codec); |
2177 parameters.codecs.push_back(kTelephoneEventCodec1); | 1820 parameters.codecs.push_back(kTelephoneEventCodec1); |
2178 parameters.codecs[0].name = "iSaC"; | 1821 parameters.codecs[0].name = "iSaC"; |
2179 parameters.codecs[0].id = 96; | 1822 parameters.codecs[0].id = 96; |
2180 parameters.codecs[2].id = 97; // wideband CN | 1823 parameters.codecs[2].id = 97; // wideband CN |
2181 parameters.codecs[4].id = 98; // DTMF | 1824 parameters.codecs[4].id = 98; // DTMF |
2182 SetSendParameters(parameters); | 1825 SetSendParameters(parameters); |
2183 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1826 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2184 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1827 EXPECT_EQ(96, send_codec_spec.payload_type); |
2185 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1828 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2186 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1829 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2187 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2188 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1830 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2189 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2190 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1831 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2191 } | 1832 } |
2192 | 1833 |
2193 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { | 1834 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
2194 public: | 1835 public: |
2195 WebRtcVoiceEngineWithSendSideBweTest() | 1836 WebRtcVoiceEngineWithSendSideBweTest() |
2196 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} | 1837 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
2197 }; | 1838 }; |
2198 | 1839 |
2199 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, | 1840 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2337 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1978 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2338 parameters.codecs.push_back(kIsacCodec); | 1979 parameters.codecs.push_back(kIsacCodec); |
2339 parameters.codecs.push_back(kCn16000Codec); | 1980 parameters.codecs.push_back(kCn16000Codec); |
2340 parameters.codecs[1].id = 97; | 1981 parameters.codecs[1].id = 97; |
2341 SetSendParameters(parameters); | 1982 SetSendParameters(parameters); |
2342 | 1983 |
2343 // Verify ISAC and VAD are corrected configured on all send channels. | 1984 // Verify ISAC and VAD are corrected configured on all send channels. |
2344 for (uint32_t ssrc : kSsrcs4) { | 1985 for (uint32_t ssrc : kSsrcs4) { |
2345 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1986 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2346 const auto& send_codec_spec = | 1987 const auto& send_codec_spec = |
2347 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 1988 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2348 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1989 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2349 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1990 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2350 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | |
2351 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1991 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2352 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2353 } | 1992 } |
2354 | 1993 |
2355 // Change to PCMU(8K) and CN(16K). | 1994 // Change to PCMU(8K) and CN(16K). |
2356 parameters.codecs[0] = kPcmuCodec; | 1995 parameters.codecs[0] = kPcmuCodec; |
2357 SetSendParameters(parameters); | 1996 SetSendParameters(parameters); |
2358 for (uint32_t ssrc : kSsrcs4) { | 1997 for (uint32_t ssrc : kSsrcs4) { |
2359 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1998 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2360 const auto& send_codec_spec = | 1999 const auto& send_codec_spec = |
2361 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 2000 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2362 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 2001 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2363 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | 2002 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2364 } | 2003 } |
2365 } | 2004 } |
2366 | 2005 |
2367 // Test we can SetSend on all send streams correctly. | 2006 // Test we can SetSend on all send streams correctly. |
2368 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 2007 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2369 SetupForMultiSendStream(); | 2008 SetupForMultiSendStream(); |
2370 | 2009 |
2371 // Create the send channels and they should be a "not sending" date. | 2010 // Create the send channels and they should be a "not sending" date. |
2372 for (uint32_t ssrc : kSsrcs4) { | 2011 for (uint32_t ssrc : kSsrcs4) { |
2373 EXPECT_TRUE(channel_->AddSendStream( | 2012 EXPECT_TRUE(channel_->AddSendStream( |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2549 } | 2188 } |
2550 | 2189 |
2551 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { | 2190 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { |
2552 EXPECT_TRUE(SetupSendStream()); | 2191 EXPECT_TRUE(SetupSendStream()); |
2553 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2192 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2554 send_parameters_.options.audio_network_adaptor_config = | 2193 send_parameters_.options.audio_network_adaptor_config = |
2555 rtc::Optional<std::string>("1234"); | 2194 rtc::Optional<std::string>("1234"); |
2556 SetSendParameters(send_parameters_); | 2195 SetSendParameters(send_parameters_); |
2557 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2196 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
2558 GetAudioNetworkAdaptorConfig(kSsrcX)); | 2197 GetAudioNetworkAdaptorConfig(kSsrcX)); |
2559 const int initial_num = call_.GetNumCreatedSendStreams(); | |
2560 cricket::AudioOptions options; | 2198 cricket::AudioOptions options; |
2561 options.audio_network_adaptor = rtc::Optional<bool>(false); | 2199 options.audio_network_adaptor = rtc::Optional<bool>(false); |
2562 SetAudioSend(kSsrcX, true, nullptr, &options); | 2200 SetAudioSend(kSsrcX, true, nullptr, &options); |
2563 // AudioSendStream expected to be recreated. | |
2564 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | |
2565 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); | 2201 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); |
2566 } | 2202 } |
2567 | 2203 |
2568 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { | 2204 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { |
2569 EXPECT_TRUE(SetupSendStream()); | 2205 EXPECT_TRUE(SetupSendStream()); |
2570 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2206 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2571 send_parameters_.options.audio_network_adaptor_config = | 2207 send_parameters_.options.audio_network_adaptor_config = |
2572 rtc::Optional<std::string>("1234"); | 2208 rtc::Optional<std::string>("1234"); |
2573 SetSendParameters(send_parameters_); | 2209 SetSendParameters(send_parameters_); |
2574 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2210 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
(...skipping 1052 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3627 webrtc::RtcEventLogNullImpl event_log; | 3263 webrtc::RtcEventLogNullImpl event_log; |
3628 std::unique_ptr<webrtc::Call> call( | 3264 std::unique_ptr<webrtc::Call> call( |
3629 webrtc::Call::Create(webrtc::Call::Config(&event_log))); | 3265 webrtc::Call::Create(webrtc::Call::Config(&event_log))); |
3630 cricket::VoiceMediaChannel* channel = engine.CreateChannel( | 3266 cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
3631 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); | 3267 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
3632 EXPECT_TRUE(channel != nullptr); | 3268 EXPECT_TRUE(channel != nullptr); |
3633 delete channel; | 3269 delete channel; |
3634 } | 3270 } |
3635 } | 3271 } |
3636 | 3272 |
3637 // Tests that the library is configured with the codecs we want. | 3273 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. |
3638 TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) { | 3274 TEST(WebRtcVoiceEngineTest, HasCorrectPayloadTypeMapping) { |
3639 // TODO(ossu): These tests should move into a future "builtin audio codecs" | |
3640 // module. | |
3641 | |
3642 // Check codecs by name. | |
3643 #ifdef WEBRTC_CODEC_OPUS | |
3644 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3645 cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr)); | |
3646 #endif | |
3647 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) | |
3648 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3649 cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr)); | |
3650 #endif | |
3651 #if (defined(WEBRTC_CODEC_ISAC)) | |
3652 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3653 cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr)); | |
3654 #endif | |
3655 #ifdef WEBRTC_CODEC_ILBC | |
3656 // Check that name matching is case-insensitive. | |
3657 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3658 cricket::AudioCodec(96, "ILBC", 8000, 0, 1), nullptr)); | |
3659 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3660 cricket::AudioCodec(96, "iLBC", 8000, 0, 1), nullptr)); | |
3661 #endif | |
3662 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3663 cricket::AudioCodec(96, "CN", 32000, 0, 1), nullptr)); | |
3664 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3665 cricket::AudioCodec(96, "CN", 16000, 0, 1), nullptr)); | |
3666 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3667 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1), nullptr)); | |
3668 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3669 cricket::AudioCodec(96, "telephone-event", 16000, 0, 1), nullptr)); | |
3670 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3671 cricket::AudioCodec(96, "telephone-event", 32000, 0, 1), nullptr)); | |
3672 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3673 cricket::AudioCodec(96, "telephone-event", 48000, 0, 1), nullptr)); | |
3674 // Check codecs with an id by id. | |
3675 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3676 cricket::AudioCodec(0, "", 8000, 0, 1), nullptr)); // PCMU | |
3677 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3678 cricket::AudioCodec(8, "", 8000, 0, 1), nullptr)); // PCMA | |
3679 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3680 cricket::AudioCodec(9, "", 8000, 0, 1), nullptr)); // G722 | |
3681 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3682 cricket::AudioCodec(13, "", 8000, 0, 1), nullptr)); // CN | |
3683 // Check sample/bitrate matching. | |
3684 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3685 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1), nullptr)); | |
3686 // Check that bad codecs fail. | |
3687 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3688 cricket::AudioCodec(99, "ABCD", 0, 0, 1), nullptr)); | |
3689 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3690 cricket::AudioCodec(88, "", 0, 0, 1), nullptr)); | |
3691 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3692 cricket::AudioCodec(0, "", 0, 0, 2), nullptr)); | |
3693 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3694 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); | |
3695 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3696 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); | |
3697 | |
3698 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. | |
3699 // TODO(ossu): Why are the payload types of codecs with non-static payload | 3275 // TODO(ossu): Why are the payload types of codecs with non-static payload |
3700 // type assignments checked here? It shouldn't really matter. | 3276 // type assignments checked here? It shouldn't really matter. |
3701 cricket::WebRtcVoiceEngine engine( | 3277 cricket::WebRtcVoiceEngine engine( |
3702 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); | 3278 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); |
3703 for (const cricket::AudioCodec& codec : engine.send_codecs()) { | 3279 for (const cricket::AudioCodec& codec : engine.send_codecs()) { |
3704 if (codec.name == "CN" && codec.clockrate == 16000) { | 3280 auto is_codec = [&codec](const char* name, int clockrate = 0) { |
| 3281 return STR_CASE_CMP(codec.name.c_str(), name) == 0 && |
| 3282 (clockrate == 0 || codec.clockrate == clockrate); |
| 3283 }; |
| 3284 if (is_codec("CN", 16000)) { |
3705 EXPECT_EQ(105, codec.id); | 3285 EXPECT_EQ(105, codec.id); |
3706 } else if (codec.name == "CN" && codec.clockrate == 32000) { | 3286 } else if (is_codec("CN", 32000)) { |
3707 EXPECT_EQ(106, codec.id); | 3287 EXPECT_EQ(106, codec.id); |
3708 } else if (codec.name == "ISAC" && codec.clockrate == 16000) { | 3288 } else if (is_codec("ISAC", 16000)) { |
3709 EXPECT_EQ(103, codec.id); | 3289 EXPECT_EQ(103, codec.id); |
3710 } else if (codec.name == "ISAC" && codec.clockrate == 32000) { | 3290 } else if (is_codec("ISAC", 32000)) { |
3711 EXPECT_EQ(104, codec.id); | 3291 EXPECT_EQ(104, codec.id); |
3712 } else if (codec.name == "G722" && codec.clockrate == 8000) { | 3292 } else if (is_codec("G722", 8000)) { |
3713 EXPECT_EQ(9, codec.id); | 3293 EXPECT_EQ(9, codec.id); |
3714 } else if (codec.name == "telephone-event" && codec.clockrate == 8000) { | 3294 } else if (is_codec("telephone-event", 8000)) { |
3715 EXPECT_EQ(126, codec.id); | 3295 EXPECT_EQ(126, codec.id); |
3716 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. | 3296 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. |
3717 // Remove these checks once both send and receive side assigns payload types | 3297 // Remove these checks once both send and receive side assigns payload types |
3718 // dynamically. | 3298 // dynamically. |
3719 } else if (codec.name == "telephone-event" && codec.clockrate == 16000) { | 3299 } else if (is_codec("telephone-event", 16000)) { |
3720 EXPECT_EQ(113, codec.id); | 3300 EXPECT_EQ(113, codec.id); |
3721 } else if (codec.name == "telephone-event" && codec.clockrate == 32000) { | 3301 } else if (is_codec("telephone-event", 32000)) { |
3722 EXPECT_EQ(112, codec.id); | 3302 EXPECT_EQ(112, codec.id); |
3723 } else if (codec.name == "telephone-event" && codec.clockrate == 48000) { | 3303 } else if (is_codec("telephone-event", 48000)) { |
3724 EXPECT_EQ(110, codec.id); | 3304 EXPECT_EQ(110, codec.id); |
3725 } else if (codec.name == "opus") { | 3305 } else if (is_codec("opus")) { |
3726 EXPECT_EQ(111, codec.id); | 3306 EXPECT_EQ(111, codec.id); |
3727 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); | 3307 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); |
3728 EXPECT_EQ("10", codec.params.find("minptime")->second); | 3308 EXPECT_EQ("10", codec.params.find("minptime")->second); |
3729 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); | 3309 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); |
3730 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); | 3310 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); |
3731 } | 3311 } |
3732 } | 3312 } |
3733 } | 3313 } |
3734 | 3314 |
3735 // Tests that VoE supports at least 32 channels | 3315 // Tests that VoE supports at least 32 channels |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3844 // Without this cast, the comparison turned unsigned and, thus, failed for -1. | 3424 // Without this cast, the comparison turned unsigned and, thus, failed for -1. |
3845 const int num_specs = static_cast<int>(specs.size()); | 3425 const int num_specs = static_cast<int>(specs.size()); |
3846 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); | 3426 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); |
3847 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); | 3427 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); |
3848 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); | 3428 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); |
3849 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); | 3429 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); |
3850 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); | 3430 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); |
3851 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); | 3431 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); |
3852 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); | 3432 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); |
3853 } | 3433 } |
OLD | NEW |