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 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1276 } | 1199 } |
1277 | 1200 |
1278 // Test that we apply codecs properly. | 1201 // Test that we apply codecs properly. |
1279 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { | 1202 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
1280 EXPECT_TRUE(SetupSendStream()); | 1203 EXPECT_TRUE(SetupSendStream()); |
1281 cricket::AudioSendParameters parameters; | 1204 cricket::AudioSendParameters parameters; |
1282 parameters.codecs.push_back(kIsacCodec); | 1205 parameters.codecs.push_back(kIsacCodec); |
1283 parameters.codecs.push_back(kPcmuCodec); | 1206 parameters.codecs.push_back(kPcmuCodec); |
1284 parameters.codecs.push_back(kCn8000Codec); | 1207 parameters.codecs.push_back(kCn8000Codec); |
1285 parameters.codecs[0].id = 96; | 1208 parameters.codecs[0].id = 96; |
1286 parameters.codecs[0].bitrate = 48000; | 1209 parameters.codecs[0].bitrate = 22000; |
1287 const int initial_num = call_.GetNumCreatedSendStreams(); | |
1288 SetSendParameters(parameters); | 1210 SetSendParameters(parameters); |
1289 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1211 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1290 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1212 EXPECT_EQ(96, send_codec_spec.payload_type); |
1291 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1213 EXPECT_EQ(22000, send_codec_spec.target_bitrate_bps); |
1292 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); | 1214 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
1293 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1215 EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000); |
1294 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1216 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
1295 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | |
1296 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1217 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1297 } | 1218 } |
1298 | 1219 |
1299 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1220 // Test that WebRtcVoiceEngine reconfigures, rather than recreates its |
1300 // to apply. | 1221 // AudioSendStream. |
1301 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1222 TEST_F(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { |
1302 EXPECT_TRUE(SetupSendStream()); | 1223 EXPECT_TRUE(SetupSendStream()); |
1303 cricket::AudioSendParameters parameters; | 1224 cricket::AudioSendParameters parameters; |
1304 parameters.codecs.push_back(kIsacCodec); | 1225 parameters.codecs.push_back(kIsacCodec); |
1305 parameters.codecs.push_back(kPcmuCodec); | 1226 parameters.codecs.push_back(kPcmuCodec); |
1306 parameters.codecs.push_back(kCn8000Codec); | 1227 parameters.codecs.push_back(kCn8000Codec); |
1307 parameters.codecs[0].id = 96; | 1228 parameters.codecs[0].id = 96; |
1308 parameters.codecs[0].bitrate = 48000; | 1229 parameters.codecs[0].bitrate = 48000; |
1309 const int initial_num = call_.GetNumCreatedSendStreams(); | 1230 const int initial_num = call_.GetNumCreatedSendStreams(); |
1310 SetSendParameters(parameters); | 1231 SetSendParameters(parameters); |
1311 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1232 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1312 // Calling SetSendCodec again with same codec which is already set. | 1233 // Calling SetSendCodec again with same codec which is already set. |
1313 // In this case media channel shouldn't send codec to VoE. | 1234 // In this case media channel shouldn't send codec to VoE. |
1314 SetSendParameters(parameters); | 1235 SetSendParameters(parameters); |
1315 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1236 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1316 } | 1237 } |
1317 | 1238 |
1318 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1239 // TODO(ossu): Revisit if these tests need to be here, now that these kinds of |
1319 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1240 // tests should be available in AudioEncoderOpusTest. |
1320 EXPECT_TRUE(SetupSendStream()); | |
1321 cricket::AudioSendParameters parameters; | |
1322 parameters.codecs.push_back(kG722CodecSdp); | |
1323 SetSendParameters(parameters); | |
1324 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | |
1325 EXPECT_STREQ("G722", gcodec.plname); | |
1326 EXPECT_EQ(1, gcodec.channels); | |
1327 EXPECT_EQ(16000, gcodec.plfreq); | |
1328 } | |
1329 | 1241 |
1330 // Test that if clockrate is not 48000 for opus, we fail. | 1242 // Test that if clockrate is not 48000 for opus, we fail. |
1331 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1243 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1332 EXPECT_TRUE(SetupSendStream()); | 1244 EXPECT_TRUE(SetupSendStream()); |
1333 cricket::AudioSendParameters parameters; | 1245 cricket::AudioSendParameters parameters; |
1334 parameters.codecs.push_back(kOpusCodec); | 1246 parameters.codecs.push_back(kOpusCodec); |
1335 parameters.codecs[0].bitrate = 0; | 1247 parameters.codecs[0].bitrate = 0; |
1336 parameters.codecs[0].clockrate = 50000; | 1248 parameters.codecs[0].clockrate = 50000; |
1337 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1249 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1338 } | 1250 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1383 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { | 1295 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { |
1384 EXPECT_TRUE(SetupSendStream()); | 1296 EXPECT_TRUE(SetupSendStream()); |
1385 cricket::AudioSendParameters parameters; | 1297 cricket::AudioSendParameters parameters; |
1386 parameters.codecs.push_back(kOpusCodec); | 1298 parameters.codecs.push_back(kOpusCodec); |
1387 parameters.codecs[0].bitrate = 0; | 1299 parameters.codecs[0].bitrate = 0; |
1388 parameters.codecs[0].channels = 1; | 1300 parameters.codecs[0].channels = 1; |
1389 parameters.codecs[0].params["stereo"] = "1"; | 1301 parameters.codecs[0].params["stereo"] = "1"; |
1390 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1302 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1391 } | 1303 } |
1392 | 1304 |
1393 // Test that with bitrate=0 and no stereo, | 1305 // Test that with bitrate=0 and no stereo, bitrate is 32000. |
1394 // channels and bitrate are 1 and 32000. | |
1395 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { | 1306 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
1396 EXPECT_TRUE(SetupSendStream()); | 1307 EXPECT_TRUE(SetupSendStream()); |
1397 cricket::AudioSendParameters parameters; | 1308 cricket::AudioSendParameters parameters; |
1398 parameters.codecs.push_back(kOpusCodec); | 1309 parameters.codecs.push_back(kOpusCodec); |
1399 parameters.codecs[0].bitrate = 0; | 1310 parameters.codecs[0].bitrate = 0; |
1400 SetSendParameters(parameters); | 1311 SetSendParameters(parameters); |
1401 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1312 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1402 } | 1313 } |
1403 | 1314 |
1404 // Test that with bitrate=0 and stereo=0, | 1315 // Test that with bitrate=0 and stereo=0, bitrate is 32000. |
1405 // channels and bitrate are 1 and 32000. | |
1406 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { | 1316 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
1407 EXPECT_TRUE(SetupSendStream()); | 1317 EXPECT_TRUE(SetupSendStream()); |
1408 cricket::AudioSendParameters parameters; | 1318 cricket::AudioSendParameters parameters; |
1409 parameters.codecs.push_back(kOpusCodec); | 1319 parameters.codecs.push_back(kOpusCodec); |
1410 parameters.codecs[0].bitrate = 0; | 1320 parameters.codecs[0].bitrate = 0; |
1411 parameters.codecs[0].params["stereo"] = "0"; | 1321 parameters.codecs[0].params["stereo"] = "0"; |
1412 SetSendParameters(parameters); | 1322 SetSendParameters(parameters); |
1413 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1323 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1414 } | 1324 } |
1415 | 1325 |
1416 // Test that with bitrate=invalid and stereo=0, | 1326 // Test that with bitrate=invalid and stereo=0, bitrate is 32000. |
1417 // channels and bitrate are 1 and 32000. | |
1418 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { | 1327 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
1419 EXPECT_TRUE(SetupSendStream()); | 1328 EXPECT_TRUE(SetupSendStream()); |
1420 cricket::AudioSendParameters parameters; | 1329 cricket::AudioSendParameters parameters; |
1421 parameters.codecs.push_back(kOpusCodec); | 1330 parameters.codecs.push_back(kOpusCodec); |
1422 parameters.codecs[0].params["stereo"] = "0"; | 1331 parameters.codecs[0].params["stereo"] = "0"; |
1423 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1332 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1424 parameters.codecs[0].bitrate = 5999; | 1333 parameters.codecs[0].bitrate = 5999; |
1425 SetSendParameters(parameters); | 1334 SetSendParameters(parameters); |
1426 CheckSendCodec(kSsrcX, "opus", 1, 6000); | 1335 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1427 | 1336 |
1428 parameters.codecs[0].bitrate = 510001; | 1337 parameters.codecs[0].bitrate = 510001; |
1429 SetSendParameters(parameters); | 1338 SetSendParameters(parameters); |
1430 CheckSendCodec(kSsrcX, "opus", 1, 510000); | 1339 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1431 } | 1340 } |
1432 | 1341 |
1433 // Test that with bitrate=0 and stereo=1, | 1342 // Test that with bitrate=0 and stereo=1, bitrate is 64000. |
1434 // channels and bitrate are 2 and 64000. | |
1435 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { | 1343 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
1436 EXPECT_TRUE(SetupSendStream()); | 1344 EXPECT_TRUE(SetupSendStream()); |
1437 cricket::AudioSendParameters parameters; | 1345 cricket::AudioSendParameters parameters; |
1438 parameters.codecs.push_back(kOpusCodec); | 1346 parameters.codecs.push_back(kOpusCodec); |
1439 parameters.codecs[0].bitrate = 0; | 1347 parameters.codecs[0].bitrate = 0; |
1440 parameters.codecs[0].params["stereo"] = "1"; | 1348 parameters.codecs[0].params["stereo"] = "1"; |
1441 SetSendParameters(parameters); | 1349 SetSendParameters(parameters); |
1442 CheckSendCodec(kSsrcX, "opus", 2, 64000); | 1350 CheckSendCodecBitrate(kSsrcX, "opus", 64000); |
1443 } | 1351 } |
1444 | 1352 |
1445 // Test that with bitrate=invalid and stereo=1, | 1353 // Test that with bitrate=invalid and stereo=1, bitrate is 64000. |
1446 // channels and bitrate are 2 and 64000. | |
1447 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { | 1354 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
1448 EXPECT_TRUE(SetupSendStream()); | 1355 EXPECT_TRUE(SetupSendStream()); |
1449 cricket::AudioSendParameters parameters; | 1356 cricket::AudioSendParameters parameters; |
1450 parameters.codecs.push_back(kOpusCodec); | 1357 parameters.codecs.push_back(kOpusCodec); |
1451 parameters.codecs[0].params["stereo"] = "1"; | 1358 parameters.codecs[0].params["stereo"] = "1"; |
1452 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1359 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1453 parameters.codecs[0].bitrate = 5999; | 1360 parameters.codecs[0].bitrate = 5999; |
1454 SetSendParameters(parameters); | 1361 SetSendParameters(parameters); |
1455 CheckSendCodec(kSsrcX, "opus", 2, 6000); | 1362 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1456 | 1363 |
1457 parameters.codecs[0].bitrate = 510001; | 1364 parameters.codecs[0].bitrate = 510001; |
1458 SetSendParameters(parameters); | 1365 SetSendParameters(parameters); |
1459 CheckSendCodec(kSsrcX, "opus", 2, 510000); | 1366 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1460 } | 1367 } |
1461 | 1368 |
1462 // Test that with bitrate=N and stereo unset, | 1369 // Test that with bitrate=N and stereo unset, bitrate is N. |
1463 // channels and bitrate are 1 and N. | |
1464 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1370 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1465 EXPECT_TRUE(SetupSendStream()); | 1371 EXPECT_TRUE(SetupSendStream()); |
1466 cricket::AudioSendParameters parameters; | 1372 cricket::AudioSendParameters parameters; |
1467 parameters.codecs.push_back(kOpusCodec); | 1373 parameters.codecs.push_back(kOpusCodec); |
1468 parameters.codecs[0].bitrate = 96000; | 1374 parameters.codecs[0].bitrate = 96000; |
1469 SetSendParameters(parameters); | 1375 SetSendParameters(parameters); |
1470 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1376 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1471 EXPECT_EQ(111, gcodec.pltype); | 1377 EXPECT_EQ(111, spec.payload_type); |
1472 EXPECT_EQ(96000, gcodec.rate); | 1378 EXPECT_EQ(96000, spec.target_bitrate_bps); |
1473 EXPECT_STREQ("opus", gcodec.plname); | 1379 EXPECT_EQ("opus", spec.format.name); |
1474 EXPECT_EQ(1, gcodec.channels); | 1380 EXPECT_EQ(2, spec.format.num_channels); |
1475 EXPECT_EQ(48000, gcodec.plfreq); | 1381 EXPECT_EQ(48000, spec.format.clockrate_hz); |
1476 } | 1382 } |
1477 | 1383 |
1478 // Test that with bitrate=N and stereo=0, | 1384 // Test that with bitrate=N and stereo=0, bitrate is N. |
1479 // channels and bitrate are 1 and N. | |
1480 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1385 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1481 EXPECT_TRUE(SetupSendStream()); | 1386 EXPECT_TRUE(SetupSendStream()); |
1482 cricket::AudioSendParameters parameters; | 1387 cricket::AudioSendParameters parameters; |
1483 parameters.codecs.push_back(kOpusCodec); | 1388 parameters.codecs.push_back(kOpusCodec); |
1484 parameters.codecs[0].bitrate = 30000; | 1389 parameters.codecs[0].bitrate = 30000; |
1485 parameters.codecs[0].params["stereo"] = "0"; | 1390 parameters.codecs[0].params["stereo"] = "0"; |
1486 SetSendParameters(parameters); | 1391 SetSendParameters(parameters); |
1487 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1392 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1488 } | 1393 } |
1489 | 1394 |
1490 // Test that with bitrate=N and without any parameters, | 1395 // Test that with bitrate=N and without any parameters, bitrate is N. |
1491 // channels and bitrate are 1 and N. | |
1492 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { | 1396 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
1493 EXPECT_TRUE(SetupSendStream()); | 1397 EXPECT_TRUE(SetupSendStream()); |
1494 cricket::AudioSendParameters parameters; | 1398 cricket::AudioSendParameters parameters; |
1495 parameters.codecs.push_back(kOpusCodec); | 1399 parameters.codecs.push_back(kOpusCodec); |
1496 parameters.codecs[0].bitrate = 30000; | 1400 parameters.codecs[0].bitrate = 30000; |
1497 SetSendParameters(parameters); | 1401 SetSendParameters(parameters); |
1498 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1402 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1499 } | 1403 } |
1500 | 1404 |
1501 // Test that with bitrate=N and stereo=1, | 1405 // Test that with bitrate=N and stereo=1, bitrate is N. |
1502 // channels and bitrate are 2 and N. | |
1503 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1406 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1504 EXPECT_TRUE(SetupSendStream()); | 1407 EXPECT_TRUE(SetupSendStream()); |
1505 cricket::AudioSendParameters parameters; | 1408 cricket::AudioSendParameters parameters; |
1506 parameters.codecs.push_back(kOpusCodec); | 1409 parameters.codecs.push_back(kOpusCodec); |
1507 parameters.codecs[0].bitrate = 30000; | 1410 parameters.codecs[0].bitrate = 30000; |
1508 parameters.codecs[0].params["stereo"] = "1"; | 1411 parameters.codecs[0].params["stereo"] = "1"; |
1509 SetSendParameters(parameters); | 1412 SetSendParameters(parameters); |
1510 CheckSendCodec(kSsrcX, "opus", 2, 30000); | 1413 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1511 } | |
1512 | |
1513 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | |
1514 // Also test that the "maxaveragebitrate" can't be set to values outside the | |
1515 // range of 6000 and 510000 | |
1516 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | |
1517 EXPECT_TRUE(SetupSendStream()); | |
1518 cricket::AudioSendParameters parameters; | |
1519 parameters.codecs.push_back(kOpusCodec); | |
1520 parameters.codecs[0].bitrate = 30000; | |
1521 // Ignore if less than 6000. | |
1522 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | |
1523 SetSendParameters(parameters); | |
1524 EXPECT_EQ(6000, GetCodecBitrate(kSsrcX)); | |
1525 | |
1526 // Ignore if larger than 510000. | |
1527 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | |
1528 SetSendParameters(parameters); | |
1529 EXPECT_EQ(510000, GetCodecBitrate(kSsrcX)); | |
1530 | |
1531 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | |
1532 SetSendParameters(parameters); | |
1533 EXPECT_EQ(200000, GetCodecBitrate(kSsrcX)); | |
1534 } | 1414 } |
1535 | 1415 |
1536 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { | 1416 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { |
1537 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", | 1417 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
1538 200000); | 1418 200000); |
1539 } | 1419 } |
1540 | 1420 |
1541 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { | 1421 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { |
1542 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); | 1422 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); |
1543 } | 1423 } |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1659 cricket::kParamValueEmpty)); | 1539 cricket::kParamValueEmpty)); |
1660 SetSendParameters(parameters); | 1540 SetSendParameters(parameters); |
1661 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); | 1541 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); |
1662 | 1542 |
1663 EXPECT_TRUE(AddRecvStream(kSsrcY)); | 1543 EXPECT_TRUE(AddRecvStream(kSsrcY)); |
1664 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); | 1544 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); |
1665 EXPECT_TRUE(AddRecvStream(kSsrcZ)); | 1545 EXPECT_TRUE(AddRecvStream(kSsrcZ)); |
1666 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); | 1546 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); |
1667 } | 1547 } |
1668 | 1548 |
1669 // Test that without useinbandfec, Opus FEC is off. | |
1670 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | |
1671 EXPECT_TRUE(SetupSendStream()); | |
1672 cricket::AudioSendParameters parameters; | |
1673 parameters.codecs.push_back(kOpusCodec); | |
1674 SetSendParameters(parameters); | |
1675 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1676 } | |
1677 | |
1678 // Test that with useinbandfec=0, Opus FEC is off. | |
1679 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | |
1680 EXPECT_TRUE(SetupSendStream()); | |
1681 cricket::AudioSendParameters parameters; | |
1682 parameters.codecs.push_back(kOpusCodec); | |
1683 parameters.codecs[0].bitrate = 0; | |
1684 parameters.codecs[0].params["useinbandfec"] = "0"; | |
1685 SetSendParameters(parameters); | |
1686 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1687 } | |
1688 | |
1689 // Test that with useinbandfec=1, Opus FEC is on. | |
1690 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | |
1691 EXPECT_TRUE(SetupSendStream()); | |
1692 cricket::AudioSendParameters parameters; | |
1693 parameters.codecs.push_back(kOpusCodec); | |
1694 parameters.codecs[0].bitrate = 0; | |
1695 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1696 SetSendParameters(parameters); | |
1697 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1698 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1699 } | |
1700 | |
1701 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | |
1702 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | |
1703 EXPECT_TRUE(SetupSendStream()); | |
1704 cricket::AudioSendParameters parameters; | |
1705 parameters.codecs.push_back(kOpusCodec); | |
1706 parameters.codecs[0].bitrate = 0; | |
1707 parameters.codecs[0].params["stereo"] = "1"; | |
1708 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1709 SetSendParameters(parameters); | |
1710 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1711 CheckSendCodec(kSsrcX, "opus", 2, 64000); | |
1712 } | |
1713 | |
1714 // Test that with non-Opus, codec FEC is off. | |
1715 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | |
1716 EXPECT_TRUE(SetupSendStream()); | |
1717 cricket::AudioSendParameters parameters; | |
1718 parameters.codecs.push_back(kIsacCodec); | |
1719 SetSendParameters(parameters); | |
1720 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1721 } | |
1722 | |
1723 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | |
1724 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | |
1725 EXPECT_TRUE(SetupSendStream()); | |
1726 cricket::AudioSendParameters parameters; | |
1727 parameters.codecs.push_back(kIsacCodec); | |
1728 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1729 SetSendParameters(parameters); | |
1730 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1731 } | |
1732 | |
1733 // Test that Opus FEC status can be changed. | |
1734 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | |
1735 EXPECT_TRUE(SetupSendStream()); | |
1736 cricket::AudioSendParameters parameters; | |
1737 parameters.codecs.push_back(kOpusCodec); | |
1738 SetSendParameters(parameters); | |
1739 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1740 | |
1741 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1742 SetSendParameters(parameters); | |
1743 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1744 } | |
1745 | |
1746 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1549 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1747 EXPECT_TRUE(SetupChannel()); | 1550 EXPECT_TRUE(SetupChannel()); |
1748 cricket::AudioSendParameters send_parameters; | 1551 cricket::AudioSendParameters send_parameters; |
1749 send_parameters.codecs.push_back(kOpusCodec); | 1552 send_parameters.codecs.push_back(kOpusCodec); |
1750 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1553 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1751 SetSendParameters(send_parameters); | 1554 SetSendParameters(send_parameters); |
1752 | 1555 |
1753 cricket::AudioRecvParameters recv_parameters; | 1556 cricket::AudioRecvParameters recv_parameters; |
1754 recv_parameters.codecs.push_back(kIsacCodec); | 1557 recv_parameters.codecs.push_back(kIsacCodec); |
1755 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1558 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1756 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 1559 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
1757 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1560 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1758 EXPECT_FALSE( | 1561 EXPECT_FALSE( |
1759 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1562 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1760 | 1563 |
1761 send_parameters.codecs = engine_->send_codecs(); | 1564 send_parameters.codecs = engine_->send_codecs(); |
1762 SetSendParameters(send_parameters); | 1565 SetSendParameters(send_parameters); |
1763 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1566 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1764 EXPECT_TRUE( | 1567 EXPECT_TRUE( |
1765 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1568 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1766 } | 1569 } |
1767 | 1570 |
1768 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | |
1769 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | |
1770 EXPECT_TRUE(SetupSendStream()); | |
1771 cricket::AudioSendParameters parameters; | |
1772 parameters.codecs.push_back(kOpusCodec); | |
1773 parameters.codecs[0].bitrate = 0; | |
1774 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1775 SetSendParameters(parameters); | |
1776 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1777 EXPECT_EQ(12000, GetCodecBitrate(kSsrcX)); | |
1778 | |
1779 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1780 SetSendParameters(parameters); | |
1781 EXPECT_EQ(24000, GetCodecBitrate(kSsrcX)); | |
1782 } | |
1783 | |
1784 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | |
1785 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | |
1786 EXPECT_TRUE(SetupSendStream()); | |
1787 cricket::AudioSendParameters parameters; | |
1788 parameters.codecs.push_back(kOpusCodec); | |
1789 parameters.codecs[0].bitrate = 0; | |
1790 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | |
1791 SetSendParameters(parameters); | |
1792 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1793 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1794 | |
1795 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1796 SetSendParameters(parameters); | |
1797 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1798 } | |
1799 | |
1800 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | |
1801 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | |
1802 EXPECT_TRUE(SetupSendStream()); | |
1803 cricket::AudioSendParameters parameters; | |
1804 parameters.codecs.push_back(kOpusCodec); | |
1805 parameters.codecs[0].bitrate = 0; | |
1806 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | |
1807 SetSendParameters(parameters); | |
1808 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1809 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1810 | |
1811 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1812 SetSendParameters(parameters); | |
1813 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1814 } | |
1815 | |
1816 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | |
1817 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | |
1818 EXPECT_TRUE(SetupSendStream()); | |
1819 cricket::AudioSendParameters parameters; | |
1820 parameters.codecs.push_back(kOpusCodec); | |
1821 parameters.codecs[0].bitrate = 0; | |
1822 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | |
1823 SetSendParameters(parameters); | |
1824 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1825 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1826 | |
1827 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1828 SetSendParameters(parameters); | |
1829 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1830 } | |
1831 | |
1832 // Test 24000 < maxplaybackrate triggers Opus full band mode. | |
1833 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | |
1834 EXPECT_TRUE(SetupSendStream()); | |
1835 cricket::AudioSendParameters parameters; | |
1836 parameters.codecs.push_back(kOpusCodec); | |
1837 parameters.codecs[0].bitrate = 0; | |
1838 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | |
1839 SetSendParameters(parameters); | |
1840 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1841 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1842 | |
1843 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1844 SetSendParameters(parameters); | |
1845 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1846 } | |
1847 | |
1848 // Test Opus that without maxplaybackrate, default playback rate is used. | |
1849 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | |
1850 EXPECT_TRUE(SetupSendStream()); | |
1851 cricket::AudioSendParameters parameters; | |
1852 parameters.codecs.push_back(kOpusCodec); | |
1853 SetSendParameters(parameters); | |
1854 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1855 } | |
1856 | |
1857 // Test the with non-Opus, maxplaybackrate has no effect. | |
1858 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | |
1859 EXPECT_TRUE(SetupSendStream()); | |
1860 cricket::AudioSendParameters parameters; | |
1861 parameters.codecs.push_back(kIsacCodec); | |
1862 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | |
1863 SetSendParameters(parameters); | |
1864 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrcX)); | |
1865 } | |
1866 | |
1867 // Test maxplaybackrate can be set on two streams. | |
1868 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | |
1869 EXPECT_TRUE(SetupSendStream()); | |
1870 cricket::AudioSendParameters parameters; | |
1871 parameters.codecs.push_back(kOpusCodec); | |
1872 SetSendParameters(parameters); | |
1873 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1874 | |
1875 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1876 SetSendParameters(parameters); | |
1877 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1878 | |
1879 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcY)); | |
1880 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcY)); | |
1881 } | |
1882 | |
1883 // Test that with usedtx=0, Opus DTX is off. | |
1884 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | |
1885 EXPECT_TRUE(SetupSendStream()); | |
1886 cricket::AudioSendParameters parameters; | |
1887 parameters.codecs.push_back(kOpusCodec); | |
1888 parameters.codecs[0].params["usedtx"] = "0"; | |
1889 SetSendParameters(parameters); | |
1890 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1891 } | |
1892 | |
1893 // Test that with usedtx=1, Opus DTX is on. | |
1894 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | |
1895 EXPECT_TRUE(SetupSendStream()); | |
1896 cricket::AudioSendParameters parameters; | |
1897 parameters.codecs.push_back(kOpusCodec); | |
1898 parameters.codecs[0].params["usedtx"] = "1"; | |
1899 SetSendParameters(parameters); | |
1900 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1901 } | |
1902 | |
1903 // Test that usedtx=1 works with stereo Opus. | |
1904 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | |
1905 EXPECT_TRUE(SetupSendStream()); | |
1906 cricket::AudioSendParameters parameters; | |
1907 parameters.codecs.push_back(kOpusCodec); | |
1908 parameters.codecs[0].params["usedtx"] = "1"; | |
1909 parameters.codecs[0].params["stereo"] = "1"; | |
1910 SetSendParameters(parameters); | |
1911 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1912 } | |
1913 | |
1914 // Test that usedtx=1 does not work with non Opus. | |
1915 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | |
1916 EXPECT_TRUE(SetupSendStream()); | |
1917 cricket::AudioSendParameters parameters; | |
1918 parameters.codecs.push_back(kIsacCodec); | |
1919 parameters.codecs[0].params["usedtx"] = "1"; | |
1920 SetSendParameters(parameters); | |
1921 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1922 } | |
1923 | |
1924 // Test that we can switch back and forth between Opus and ISAC with CN. | 1571 // Test that we can switch back and forth between Opus and ISAC with CN. |
1925 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1572 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1926 EXPECT_TRUE(SetupSendStream()); | 1573 EXPECT_TRUE(SetupSendStream()); |
1927 | 1574 |
1928 cricket::AudioSendParameters opus_parameters; | 1575 cricket::AudioSendParameters opus_parameters; |
1929 opus_parameters.codecs.push_back(kOpusCodec); | 1576 opus_parameters.codecs.push_back(kOpusCodec); |
1930 SetSendParameters(opus_parameters); | 1577 SetSendParameters(opus_parameters); |
1931 { | 1578 { |
1932 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1579 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1933 EXPECT_EQ(111, gcodec.pltype); | 1580 EXPECT_EQ(111, spec.payload_type); |
1934 EXPECT_STREQ("opus", gcodec.plname); | 1581 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1935 } | 1582 } |
1936 | 1583 |
1937 cricket::AudioSendParameters isac_parameters; | 1584 cricket::AudioSendParameters isac_parameters; |
1938 isac_parameters.codecs.push_back(kIsacCodec); | 1585 isac_parameters.codecs.push_back(kIsacCodec); |
1939 isac_parameters.codecs.push_back(kCn16000Codec); | 1586 isac_parameters.codecs.push_back(kCn16000Codec); |
1940 isac_parameters.codecs.push_back(kOpusCodec); | 1587 isac_parameters.codecs.push_back(kOpusCodec); |
1941 SetSendParameters(isac_parameters); | 1588 SetSendParameters(isac_parameters); |
1942 { | 1589 { |
1943 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1590 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1944 EXPECT_EQ(103, gcodec.pltype); | 1591 EXPECT_EQ(103, spec.payload_type); |
1945 EXPECT_STREQ("ISAC", gcodec.plname); | 1592 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1946 } | 1593 } |
1947 | 1594 |
1948 SetSendParameters(opus_parameters); | 1595 SetSendParameters(opus_parameters); |
1949 { | 1596 { |
1950 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1597 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1951 EXPECT_EQ(111, gcodec.pltype); | 1598 EXPECT_EQ(111, spec.payload_type); |
1952 EXPECT_STREQ("opus", gcodec.plname); | 1599 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1953 } | 1600 } |
1954 } | 1601 } |
1955 | 1602 |
1956 // Test that we handle various ways of specifying bitrate. | 1603 // Test that we handle various ways of specifying bitrate. |
1957 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1604 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1958 EXPECT_TRUE(SetupSendStream()); | 1605 EXPECT_TRUE(SetupSendStream()); |
1959 cricket::AudioSendParameters parameters; | 1606 cricket::AudioSendParameters parameters; |
1960 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1607 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1961 SetSendParameters(parameters); | 1608 SetSendParameters(parameters); |
1962 { | 1609 { |
1963 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1610 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1964 EXPECT_EQ(103, gcodec.pltype); | 1611 EXPECT_EQ(103, spec.payload_type); |
1965 EXPECT_STREQ("ISAC", gcodec.plname); | 1612 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1966 EXPECT_EQ(32000, gcodec.rate); | 1613 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1967 } | 1614 } |
1968 | 1615 |
1969 parameters.codecs[0].bitrate = 0; // bitrate == default | 1616 parameters.codecs[0].bitrate = 0; // bitrate == default |
1970 SetSendParameters(parameters); | 1617 SetSendParameters(parameters); |
1971 { | 1618 { |
1972 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1619 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1973 EXPECT_EQ(103, gcodec.pltype); | 1620 EXPECT_EQ(103, spec.payload_type); |
1974 EXPECT_STREQ("ISAC", gcodec.plname); | 1621 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1975 EXPECT_EQ(32000, gcodec.rate); | 1622 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1976 } | 1623 } |
1977 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1624 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1978 SetSendParameters(parameters); | 1625 SetSendParameters(parameters); |
1979 { | 1626 { |
1980 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1627 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1981 EXPECT_EQ(103, gcodec.pltype); | 1628 EXPECT_EQ(103, spec.payload_type); |
1982 EXPECT_STREQ("ISAC", gcodec.plname); | 1629 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1983 EXPECT_EQ(28000, gcodec.rate); | 1630 EXPECT_EQ(28000, spec.target_bitrate_bps); |
1984 } | 1631 } |
1985 | 1632 |
1986 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1633 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1987 SetSendParameters(parameters); | 1634 SetSendParameters(parameters); |
1988 { | 1635 { |
1989 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1636 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1990 EXPECT_EQ(0, gcodec.pltype); | 1637 EXPECT_EQ(0, spec.payload_type); |
1991 EXPECT_STREQ("PCMU", gcodec.plname); | 1638 EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); |
1992 EXPECT_EQ(64000, gcodec.rate); | 1639 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1993 } | 1640 } |
1994 | 1641 |
1995 parameters.codecs[0].bitrate = 0; // bitrate == default | 1642 parameters.codecs[0].bitrate = 0; // bitrate == default |
1996 SetSendParameters(parameters); | 1643 SetSendParameters(parameters); |
1997 { | 1644 { |
1998 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1645 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1999 EXPECT_EQ(0, gcodec.pltype); | 1646 EXPECT_EQ(0, spec.payload_type); |
2000 EXPECT_STREQ("PCMU", gcodec.plname); | 1647 EXPECT_STREQ("PCMU", spec.format.name.c_str()); |
2001 EXPECT_EQ(64000, gcodec.rate); | 1648 EXPECT_EQ(64000, spec.target_bitrate_bps); |
2002 } | 1649 } |
2003 | 1650 |
2004 parameters.codecs[0] = kOpusCodec; | 1651 parameters.codecs[0] = kOpusCodec; |
2005 parameters.codecs[0].bitrate = 0; // bitrate == default | 1652 parameters.codecs[0].bitrate = 0; // bitrate == default |
2006 SetSendParameters(parameters); | 1653 SetSendParameters(parameters); |
2007 { | 1654 { |
2008 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1655 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2009 EXPECT_EQ(111, gcodec.pltype); | 1656 EXPECT_EQ(111, spec.payload_type); |
2010 EXPECT_STREQ("opus", gcodec.plname); | 1657 EXPECT_STREQ("opus", spec.format.name.c_str()); |
2011 EXPECT_EQ(32000, gcodec.rate); | 1658 EXPECT_EQ(32000, spec.target_bitrate_bps); |
2012 } | 1659 } |
2013 } | 1660 } |
2014 | 1661 |
2015 // Test that we could set packet size specified in kCodecParamPTime. | |
2016 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | |
2017 EXPECT_TRUE(SetupSendStream()); | |
2018 cricket::AudioSendParameters parameters; | |
2019 parameters.codecs.push_back(kOpusCodec); | |
2020 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | |
2021 SetSendParameters(parameters); | |
2022 EXPECT_EQ(1920, GetCodecPacSize(kSsrcX)); // Opus gets 40ms. | |
2023 | |
2024 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | |
2025 SetSendParameters(parameters); | |
2026 EXPECT_EQ(480, GetCodecPacSize(kSsrcX)); // Opus gets 10ms. | |
2027 | |
2028 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | |
2029 SetSendParameters(parameters); | |
2030 EXPECT_EQ(2880, GetCodecPacSize(kSsrcX)); // Opus gets 60ms. | |
2031 | |
2032 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | |
2033 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | |
2034 SetSendParameters(parameters); | |
2035 EXPECT_EQ(480, GetCodecPacSize( | |
2036 kSsrcX)); // Isac gets 30ms as the next smallest value. | |
2037 | |
2038 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | |
2039 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | |
2040 SetSendParameters(parameters); | |
2041 EXPECT_EQ(640, GetCodecPacSize( | |
2042 kSsrcX)); // G722 gets 40ms @16kHz as defined in VoE. | |
2043 } | |
2044 | |
2045 // Test that we fail if no codecs are specified. | 1662 // Test that we fail if no codecs are specified. |
2046 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1663 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
2047 EXPECT_TRUE(SetupSendStream()); | 1664 EXPECT_TRUE(SetupSendStream()); |
2048 cricket::AudioSendParameters parameters; | 1665 cricket::AudioSendParameters parameters; |
2049 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1666 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
2050 } | 1667 } |
2051 | 1668 |
2052 // Test that we can set send codecs even with telephone-event codec as the first | 1669 // Test that we can set send codecs even with telephone-event codec as the first |
2053 // one on the list. | 1670 // one on the list. |
2054 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1671 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
2055 EXPECT_TRUE(SetupSendStream()); | 1672 EXPECT_TRUE(SetupSendStream()); |
2056 cricket::AudioSendParameters parameters; | 1673 cricket::AudioSendParameters parameters; |
2057 parameters.codecs.push_back(kTelephoneEventCodec1); | 1674 parameters.codecs.push_back(kTelephoneEventCodec1); |
2058 parameters.codecs.push_back(kIsacCodec); | 1675 parameters.codecs.push_back(kIsacCodec); |
2059 parameters.codecs.push_back(kPcmuCodec); | 1676 parameters.codecs.push_back(kPcmuCodec); |
2060 parameters.codecs[0].id = 98; // DTMF | 1677 parameters.codecs[0].id = 98; // DTMF |
2061 parameters.codecs[1].id = 96; | 1678 parameters.codecs[1].id = 96; |
2062 SetSendParameters(parameters); | 1679 SetSendParameters(parameters); |
2063 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1680 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2064 EXPECT_EQ(96, gcodec.pltype); | 1681 EXPECT_EQ(96, spec.payload_type); |
2065 EXPECT_STREQ("ISAC", gcodec.plname); | 1682 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
2066 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1683 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2067 } | 1684 } |
2068 | 1685 |
2069 // Test that payload type range is limited for telephone-event codec. | 1686 // Test that payload type range is limited for telephone-event codec. |
2070 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1687 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
2071 EXPECT_TRUE(SetupSendStream()); | 1688 EXPECT_TRUE(SetupSendStream()); |
2072 cricket::AudioSendParameters parameters; | 1689 cricket::AudioSendParameters parameters; |
2073 parameters.codecs.push_back(kTelephoneEventCodec2); | 1690 parameters.codecs.push_back(kTelephoneEventCodec2); |
2074 parameters.codecs.push_back(kIsacCodec); | 1691 parameters.codecs.push_back(kIsacCodec); |
2075 parameters.codecs[0].id = 0; // DTMF | 1692 parameters.codecs[0].id = 0; // DTMF |
(...skipping 15 matching lines...) Expand all Loading... |
2091 // one on the list. | 1708 // one on the list. |
2092 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1709 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
2093 EXPECT_TRUE(SetupSendStream()); | 1710 EXPECT_TRUE(SetupSendStream()); |
2094 cricket::AudioSendParameters parameters; | 1711 cricket::AudioSendParameters parameters; |
2095 parameters.codecs.push_back(kCn16000Codec); | 1712 parameters.codecs.push_back(kCn16000Codec); |
2096 parameters.codecs.push_back(kIsacCodec); | 1713 parameters.codecs.push_back(kIsacCodec); |
2097 parameters.codecs.push_back(kPcmuCodec); | 1714 parameters.codecs.push_back(kPcmuCodec); |
2098 parameters.codecs[0].id = 98; // wideband CN | 1715 parameters.codecs[0].id = 98; // wideband CN |
2099 parameters.codecs[1].id = 96; | 1716 parameters.codecs[1].id = 96; |
2100 SetSendParameters(parameters); | 1717 SetSendParameters(parameters); |
2101 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1718 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2102 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1719 EXPECT_EQ(96, send_codec_spec.payload_type); |
2103 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1720 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2104 EXPECT_EQ(98, send_codec_spec.cng_payload_type); | 1721 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
2105 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2106 } | 1722 } |
2107 | 1723 |
2108 // Test that we set VAD and DTMF types correctly as caller. | 1724 // Test that we set VAD and DTMF types correctly as caller. |
2109 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1725 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
2110 EXPECT_TRUE(SetupSendStream()); | 1726 EXPECT_TRUE(SetupSendStream()); |
2111 cricket::AudioSendParameters parameters; | 1727 cricket::AudioSendParameters parameters; |
2112 parameters.codecs.push_back(kIsacCodec); | 1728 parameters.codecs.push_back(kIsacCodec); |
2113 parameters.codecs.push_back(kPcmuCodec); | 1729 parameters.codecs.push_back(kPcmuCodec); |
2114 // TODO(juberti): cn 32000 | 1730 // TODO(juberti): cn 32000 |
2115 parameters.codecs.push_back(kCn16000Codec); | 1731 parameters.codecs.push_back(kCn16000Codec); |
2116 parameters.codecs.push_back(kCn8000Codec); | 1732 parameters.codecs.push_back(kCn8000Codec); |
2117 parameters.codecs.push_back(kTelephoneEventCodec1); | 1733 parameters.codecs.push_back(kTelephoneEventCodec1); |
2118 parameters.codecs[0].id = 96; | 1734 parameters.codecs[0].id = 96; |
2119 parameters.codecs[2].id = 97; // wideband CN | 1735 parameters.codecs[2].id = 97; // wideband CN |
2120 parameters.codecs[4].id = 98; // DTMF | 1736 parameters.codecs[4].id = 98; // DTMF |
2121 SetSendParameters(parameters); | 1737 SetSendParameters(parameters); |
2122 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1738 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2123 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1739 EXPECT_EQ(96, send_codec_spec.payload_type); |
2124 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1740 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2125 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1741 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2126 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2127 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1742 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2128 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2129 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1743 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2130 } | 1744 } |
2131 | 1745 |
2132 // Test that we set VAD and DTMF types correctly as callee. | 1746 // Test that we set VAD and DTMF types correctly as callee. |
2133 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1747 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
2134 EXPECT_TRUE(SetupChannel()); | 1748 EXPECT_TRUE(SetupChannel()); |
2135 cricket::AudioSendParameters parameters; | 1749 cricket::AudioSendParameters parameters; |
2136 parameters.codecs.push_back(kIsacCodec); | 1750 parameters.codecs.push_back(kIsacCodec); |
2137 parameters.codecs.push_back(kPcmuCodec); | 1751 parameters.codecs.push_back(kPcmuCodec); |
2138 // TODO(juberti): cn 32000 | 1752 // TODO(juberti): cn 32000 |
2139 parameters.codecs.push_back(kCn16000Codec); | 1753 parameters.codecs.push_back(kCn16000Codec); |
2140 parameters.codecs.push_back(kCn8000Codec); | 1754 parameters.codecs.push_back(kCn8000Codec); |
2141 parameters.codecs.push_back(kTelephoneEventCodec2); | 1755 parameters.codecs.push_back(kTelephoneEventCodec2); |
2142 parameters.codecs[0].id = 96; | 1756 parameters.codecs[0].id = 96; |
2143 parameters.codecs[2].id = 97; // wideband CN | 1757 parameters.codecs[2].id = 97; // wideband CN |
2144 parameters.codecs[4].id = 98; // DTMF | 1758 parameters.codecs[4].id = 98; // DTMF |
2145 SetSendParameters(parameters); | 1759 SetSendParameters(parameters); |
2146 EXPECT_TRUE(channel_->AddSendStream( | 1760 EXPECT_TRUE(channel_->AddSendStream( |
2147 cricket::StreamParams::CreateLegacy(kSsrcX))); | 1761 cricket::StreamParams::CreateLegacy(kSsrcX))); |
2148 | 1762 |
2149 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1763 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2150 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1764 EXPECT_EQ(96, send_codec_spec.payload_type); |
2151 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1765 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2152 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1766 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2153 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2154 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1767 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2155 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2156 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1768 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2157 } | 1769 } |
2158 | 1770 |
2159 // Test that we only apply VAD if we have a CN codec that matches the | 1771 // Test that we only apply VAD if we have a CN codec that matches the |
2160 // send codec clockrate. | 1772 // send codec clockrate. |
2161 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1773 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
2162 EXPECT_TRUE(SetupSendStream()); | 1774 EXPECT_TRUE(SetupSendStream()); |
2163 cricket::AudioSendParameters parameters; | 1775 cricket::AudioSendParameters parameters; |
2164 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1776 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2165 parameters.codecs.push_back(kIsacCodec); | 1777 parameters.codecs.push_back(kIsacCodec); |
2166 parameters.codecs.push_back(kCn16000Codec); | 1778 parameters.codecs.push_back(kCn16000Codec); |
2167 parameters.codecs[1].id = 97; | 1779 parameters.codecs[1].id = 97; |
2168 SetSendParameters(parameters); | 1780 SetSendParameters(parameters); |
2169 { | 1781 { |
2170 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1782 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2171 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1783 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2172 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1784 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2173 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2174 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1785 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2175 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2176 } | 1786 } |
2177 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1787 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
2178 parameters.codecs[0] = kPcmuCodec; | 1788 parameters.codecs[0] = kPcmuCodec; |
2179 SetSendParameters(parameters); | 1789 SetSendParameters(parameters); |
2180 { | 1790 { |
2181 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1791 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2182 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1792 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2183 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1793 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2184 } | 1794 } |
2185 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1795 // Set PCMU(8K) and CN(8K). VAD should be activated. |
2186 parameters.codecs[1] = kCn8000Codec; | 1796 parameters.codecs[1] = kCn8000Codec; |
2187 SetSendParameters(parameters); | 1797 SetSendParameters(parameters); |
2188 { | 1798 { |
2189 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1799 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2190 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1800 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2191 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1801 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2192 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2193 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1802 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
2194 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | |
2195 } | 1803 } |
2196 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1804 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
2197 parameters.codecs[0] = kIsacCodec; | 1805 parameters.codecs[0] = kIsacCodec; |
2198 SetSendParameters(parameters); | 1806 SetSendParameters(parameters); |
2199 { | 1807 { |
2200 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1808 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2201 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1809 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2202 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1810 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2203 } | 1811 } |
2204 } | 1812 } |
2205 | 1813 |
2206 // Test that we perform case-insensitive matching of codec names. | 1814 // Test that we perform case-insensitive matching of codec names. |
2207 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1815 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
2208 EXPECT_TRUE(SetupSendStream()); | 1816 EXPECT_TRUE(SetupSendStream()); |
2209 cricket::AudioSendParameters parameters; | 1817 cricket::AudioSendParameters parameters; |
2210 parameters.codecs.push_back(kIsacCodec); | 1818 parameters.codecs.push_back(kIsacCodec); |
2211 parameters.codecs.push_back(kPcmuCodec); | 1819 parameters.codecs.push_back(kPcmuCodec); |
2212 parameters.codecs.push_back(kCn16000Codec); | 1820 parameters.codecs.push_back(kCn16000Codec); |
2213 parameters.codecs.push_back(kCn8000Codec); | 1821 parameters.codecs.push_back(kCn8000Codec); |
2214 parameters.codecs.push_back(kTelephoneEventCodec1); | 1822 parameters.codecs.push_back(kTelephoneEventCodec1); |
2215 parameters.codecs[0].name = "iSaC"; | 1823 parameters.codecs[0].name = "iSaC"; |
2216 parameters.codecs[0].id = 96; | 1824 parameters.codecs[0].id = 96; |
2217 parameters.codecs[2].id = 97; // wideband CN | 1825 parameters.codecs[2].id = 97; // wideband CN |
2218 parameters.codecs[4].id = 98; // DTMF | 1826 parameters.codecs[4].id = 98; // DTMF |
2219 SetSendParameters(parameters); | 1827 SetSendParameters(parameters); |
2220 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1828 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2221 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1829 EXPECT_EQ(96, send_codec_spec.payload_type); |
2222 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1830 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2223 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1831 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2224 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2225 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1832 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2226 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2227 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1833 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2228 } | 1834 } |
2229 | 1835 |
2230 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { | 1836 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
2231 public: | 1837 public: |
2232 WebRtcVoiceEngineWithSendSideBweTest() | 1838 WebRtcVoiceEngineWithSendSideBweTest() |
2233 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} | 1839 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
2234 }; | 1840 }; |
2235 | 1841 |
2236 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, | 1842 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2374 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1980 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2375 parameters.codecs.push_back(kIsacCodec); | 1981 parameters.codecs.push_back(kIsacCodec); |
2376 parameters.codecs.push_back(kCn16000Codec); | 1982 parameters.codecs.push_back(kCn16000Codec); |
2377 parameters.codecs[1].id = 97; | 1983 parameters.codecs[1].id = 97; |
2378 SetSendParameters(parameters); | 1984 SetSendParameters(parameters); |
2379 | 1985 |
2380 // Verify ISAC and VAD are corrected configured on all send channels. | 1986 // Verify ISAC and VAD are corrected configured on all send channels. |
2381 for (uint32_t ssrc : kSsrcs4) { | 1987 for (uint32_t ssrc : kSsrcs4) { |
2382 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1988 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2383 const auto& send_codec_spec = | 1989 const auto& send_codec_spec = |
2384 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 1990 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2385 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1991 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2386 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1992 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2387 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | |
2388 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1993 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2389 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2390 } | 1994 } |
2391 | 1995 |
2392 // Change to PCMU(8K) and CN(16K). | 1996 // Change to PCMU(8K) and CN(16K). |
2393 parameters.codecs[0] = kPcmuCodec; | 1997 parameters.codecs[0] = kPcmuCodec; |
2394 SetSendParameters(parameters); | 1998 SetSendParameters(parameters); |
2395 for (uint32_t ssrc : kSsrcs4) { | 1999 for (uint32_t ssrc : kSsrcs4) { |
2396 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 2000 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2397 const auto& send_codec_spec = | 2001 const auto& send_codec_spec = |
2398 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 2002 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2399 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 2003 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2400 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | 2004 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2401 } | 2005 } |
2402 } | 2006 } |
2403 | 2007 |
2404 // Test we can SetSend on all send streams correctly. | 2008 // Test we can SetSend on all send streams correctly. |
2405 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 2009 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2406 SetupForMultiSendStream(); | 2010 SetupForMultiSendStream(); |
2407 | 2011 |
2408 // Create the send channels and they should be a "not sending" date. | 2012 // Create the send channels and they should be a "not sending" date. |
2409 for (uint32_t ssrc : kSsrcs4) { | 2013 for (uint32_t ssrc : kSsrcs4) { |
2410 EXPECT_TRUE(channel_->AddSendStream( | 2014 EXPECT_TRUE(channel_->AddSendStream( |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2586 } | 2190 } |
2587 | 2191 |
2588 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { | 2192 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { |
2589 EXPECT_TRUE(SetupSendStream()); | 2193 EXPECT_TRUE(SetupSendStream()); |
2590 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2194 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2591 send_parameters_.options.audio_network_adaptor_config = | 2195 send_parameters_.options.audio_network_adaptor_config = |
2592 rtc::Optional<std::string>("1234"); | 2196 rtc::Optional<std::string>("1234"); |
2593 SetSendParameters(send_parameters_); | 2197 SetSendParameters(send_parameters_); |
2594 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2198 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
2595 GetAudioNetworkAdaptorConfig(kSsrcX)); | 2199 GetAudioNetworkAdaptorConfig(kSsrcX)); |
2596 const int initial_num = call_.GetNumCreatedSendStreams(); | |
2597 cricket::AudioOptions options; | 2200 cricket::AudioOptions options; |
2598 options.audio_network_adaptor = rtc::Optional<bool>(false); | 2201 options.audio_network_adaptor = rtc::Optional<bool>(false); |
2599 SetAudioSend(kSsrcX, true, nullptr, &options); | 2202 SetAudioSend(kSsrcX, true, nullptr, &options); |
2600 // AudioSendStream expected to be recreated. | |
2601 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | |
2602 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); | 2203 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); |
2603 } | 2204 } |
2604 | 2205 |
2605 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { | 2206 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { |
2606 EXPECT_TRUE(SetupSendStream()); | 2207 EXPECT_TRUE(SetupSendStream()); |
2607 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2208 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2608 send_parameters_.options.audio_network_adaptor_config = | 2209 send_parameters_.options.audio_network_adaptor_config = |
2609 rtc::Optional<std::string>("1234"); | 2210 rtc::Optional<std::string>("1234"); |
2610 SetSendParameters(send_parameters_); | 2211 SetSendParameters(send_parameters_); |
2611 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2212 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
(...skipping 1052 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3664 webrtc::RtcEventLogNullImpl event_log; | 3265 webrtc::RtcEventLogNullImpl event_log; |
3665 std::unique_ptr<webrtc::Call> call( | 3266 std::unique_ptr<webrtc::Call> call( |
3666 webrtc::Call::Create(webrtc::Call::Config(&event_log))); | 3267 webrtc::Call::Create(webrtc::Call::Config(&event_log))); |
3667 cricket::VoiceMediaChannel* channel = engine.CreateChannel( | 3268 cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
3668 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); | 3269 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
3669 EXPECT_TRUE(channel != nullptr); | 3270 EXPECT_TRUE(channel != nullptr); |
3670 delete channel; | 3271 delete channel; |
3671 } | 3272 } |
3672 } | 3273 } |
3673 | 3274 |
3674 // Tests that the library is configured with the codecs we want. | 3275 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. |
3675 TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) { | 3276 TEST(WebRtcVoiceEngineTest, HasCorrectPayloadTypeMapping) { |
3676 // TODO(ossu): These tests should move into a future "builtin audio codecs" | |
3677 // module. | |
3678 | |
3679 // Check codecs by name. | |
3680 #ifdef WEBRTC_CODEC_OPUS | |
3681 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3682 cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr)); | |
3683 #endif | |
3684 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) | |
3685 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3686 cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr)); | |
3687 #endif | |
3688 #if (defined(WEBRTC_CODEC_ISAC)) | |
3689 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3690 cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr)); | |
3691 #endif | |
3692 #ifdef WEBRTC_CODEC_ILBC | |
3693 // Check that name matching is case-insensitive. | |
3694 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3695 cricket::AudioCodec(96, "ILBC", 8000, 0, 1), nullptr)); | |
3696 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3697 cricket::AudioCodec(96, "iLBC", 8000, 0, 1), nullptr)); | |
3698 #endif | |
3699 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3700 cricket::AudioCodec(96, "CN", 32000, 0, 1), nullptr)); | |
3701 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3702 cricket::AudioCodec(96, "CN", 16000, 0, 1), nullptr)); | |
3703 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3704 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1), nullptr)); | |
3705 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3706 cricket::AudioCodec(96, "telephone-event", 16000, 0, 1), nullptr)); | |
3707 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3708 cricket::AudioCodec(96, "telephone-event", 32000, 0, 1), nullptr)); | |
3709 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3710 cricket::AudioCodec(96, "telephone-event", 48000, 0, 1), nullptr)); | |
3711 // Check codecs with an id by id. | |
3712 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3713 cricket::AudioCodec(0, "", 8000, 0, 1), nullptr)); // PCMU | |
3714 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3715 cricket::AudioCodec(8, "", 8000, 0, 1), nullptr)); // PCMA | |
3716 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3717 cricket::AudioCodec(9, "", 8000, 0, 1), nullptr)); // G722 | |
3718 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3719 cricket::AudioCodec(13, "", 8000, 0, 1), nullptr)); // CN | |
3720 // Check sample/bitrate matching. | |
3721 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3722 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1), nullptr)); | |
3723 // Check that bad codecs fail. | |
3724 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3725 cricket::AudioCodec(99, "ABCD", 0, 0, 1), nullptr)); | |
3726 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3727 cricket::AudioCodec(88, "", 0, 0, 1), nullptr)); | |
3728 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3729 cricket::AudioCodec(0, "", 0, 0, 2), nullptr)); | |
3730 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3731 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); | |
3732 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3733 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); | |
3734 | |
3735 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. | |
3736 // TODO(ossu): Why are the payload types of codecs with non-static payload | 3277 // TODO(ossu): Why are the payload types of codecs with non-static payload |
3737 // type assignments checked here? It shouldn't really matter. | 3278 // type assignments checked here? It shouldn't really matter. |
3738 cricket::WebRtcVoiceEngine engine( | 3279 cricket::WebRtcVoiceEngine engine( |
3739 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); | 3280 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); |
3740 for (const cricket::AudioCodec& codec : engine.send_codecs()) { | 3281 for (const cricket::AudioCodec& codec : engine.send_codecs()) { |
3741 if (codec.name == "CN" && codec.clockrate == 16000) { | 3282 auto is_codec = [&codec](const char* name, int clockrate = 0) { |
| 3283 return STR_CASE_CMP(codec.name.c_str(), name) == 0 && |
| 3284 (clockrate == 0 || codec.clockrate == clockrate); |
| 3285 }; |
| 3286 if (is_codec("CN", 16000)) { |
3742 EXPECT_EQ(105, codec.id); | 3287 EXPECT_EQ(105, codec.id); |
3743 } else if (codec.name == "CN" && codec.clockrate == 32000) { | 3288 } else if (is_codec("CN", 32000)) { |
3744 EXPECT_EQ(106, codec.id); | 3289 EXPECT_EQ(106, codec.id); |
3745 } else if (codec.name == "ISAC" && codec.clockrate == 16000) { | 3290 } else if (is_codec("ISAC", 16000)) { |
3746 EXPECT_EQ(103, codec.id); | 3291 EXPECT_EQ(103, codec.id); |
3747 } else if (codec.name == "ISAC" && codec.clockrate == 32000) { | 3292 } else if (is_codec("ISAC", 32000)) { |
3748 EXPECT_EQ(104, codec.id); | 3293 EXPECT_EQ(104, codec.id); |
3749 } else if (codec.name == "G722" && codec.clockrate == 8000) { | 3294 } else if (is_codec("G722", 8000)) { |
3750 EXPECT_EQ(9, codec.id); | 3295 EXPECT_EQ(9, codec.id); |
3751 } else if (codec.name == "telephone-event" && codec.clockrate == 8000) { | 3296 } else if (is_codec("telephone-event", 8000)) { |
3752 EXPECT_EQ(126, codec.id); | 3297 EXPECT_EQ(126, codec.id); |
3753 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. | 3298 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. |
3754 // Remove these checks once both send and receive side assigns payload types | 3299 // Remove these checks once both send and receive side assigns payload types |
3755 // dynamically. | 3300 // dynamically. |
3756 } else if (codec.name == "telephone-event" && codec.clockrate == 16000) { | 3301 } else if (is_codec("telephone-event", 16000)) { |
3757 EXPECT_EQ(113, codec.id); | 3302 EXPECT_EQ(113, codec.id); |
3758 } else if (codec.name == "telephone-event" && codec.clockrate == 32000) { | 3303 } else if (is_codec("telephone-event", 32000)) { |
3759 EXPECT_EQ(112, codec.id); | 3304 EXPECT_EQ(112, codec.id); |
3760 } else if (codec.name == "telephone-event" && codec.clockrate == 48000) { | 3305 } else if (is_codec("telephone-event", 48000)) { |
3761 EXPECT_EQ(110, codec.id); | 3306 EXPECT_EQ(110, codec.id); |
3762 } else if (codec.name == "opus") { | 3307 } else if (is_codec("opus")) { |
3763 EXPECT_EQ(111, codec.id); | 3308 EXPECT_EQ(111, codec.id); |
3764 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); | 3309 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); |
3765 EXPECT_EQ("10", codec.params.find("minptime")->second); | 3310 EXPECT_EQ("10", codec.params.find("minptime")->second); |
3766 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); | 3311 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); |
3767 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); | 3312 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); |
3768 } | 3313 } |
3769 } | 3314 } |
3770 } | 3315 } |
3771 | 3316 |
3772 // Tests that VoE supports at least 32 channels | 3317 // Tests that VoE supports at least 32 channels |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3881 // Without this cast, the comparison turned unsigned and, thus, failed for -1. | 3426 // Without this cast, the comparison turned unsigned and, thus, failed for -1. |
3882 const int num_specs = static_cast<int>(specs.size()); | 3427 const int num_specs = static_cast<int>(specs.size()); |
3883 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); | 3428 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); |
3884 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); | 3429 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); |
3885 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); | 3430 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); |
3886 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); | 3431 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); |
3887 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); | 3432 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); |
3888 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); | 3433 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); |
3889 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); | 3434 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); |
3890 } | 3435 } |
OLD | NEW |