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 22 matching lines...) Expand all Loading... | |
33 | 33 |
34 using testing::Return; | 34 using testing::Return; |
35 using testing::StrictMock; | 35 using testing::StrictMock; |
36 | 36 |
37 namespace { | 37 namespace { |
38 | 38 |
39 constexpr uint32_t kMaxUnsignaledRecvStreams = 1; | 39 constexpr uint32_t kMaxUnsignaledRecvStreams = 1; |
40 | 40 |
41 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); | 41 const cricket::AudioCodec kPcmuCodec(0, "PCMU", 8000, 64000, 1); |
42 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); | 42 const cricket::AudioCodec kIsacCodec(103, "ISAC", 16000, 32000, 1); |
43 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 64000, 2); | 43 const cricket::AudioCodec kOpusCodec(111, "opus", 48000, 32000, 2); |
44 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); | 44 const cricket::AudioCodec kG722CodecVoE(9, "G722", 16000, 64000, 1); |
45 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); | 45 const cricket::AudioCodec kG722CodecSdp(9, "G722", 8000, 64000, 1); |
46 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); | 46 const cricket::AudioCodec kCn8000Codec(13, "CN", 8000, 0, 1); |
47 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); | 47 const cricket::AudioCodec kCn16000Codec(105, "CN", 16000, 0, 1); |
48 const cricket::AudioCodec | 48 const cricket::AudioCodec |
49 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); | 49 kTelephoneEventCodec1(106, "telephone-event", 8000, 0, 1); |
50 const cricket::AudioCodec | 50 const cricket::AudioCodec |
51 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); | 51 kTelephoneEventCodec2(107, "telephone-event", 32000, 0, 1); |
52 const webrtc::CodecInst kExpectedOpusCodecInst{0, "opus", 48000, 0, 2, 0}; | |
52 | 53 |
53 const uint32_t kSsrc0 = 0; | 54 const uint32_t kSsrc0 = 0; |
54 const uint32_t kSsrc1 = 1; | 55 const uint32_t kSsrc1 = 1; |
55 const uint32_t kSsrcX = 0x99; | 56 const uint32_t kSsrcX = 0x99; |
56 const uint32_t kSsrcY = 0x17; | 57 const uint32_t kSsrcY = 0x17; |
57 const uint32_t kSsrcZ = 0x42; | 58 const uint32_t kSsrcZ = 0x42; |
58 const uint32_t kSsrcW = 0x02; | 59 const uint32_t kSsrcW = 0x02; |
59 const uint32_t kSsrcs4[] = { 11, 200, 30, 44 }; | 60 const uint32_t kSsrcs4[] = { 11, 200, 30, 44 }; |
60 | 61 |
61 constexpr int kRtpHistoryMs = 5000; | 62 constexpr int kRtpHistoryMs = 5000; |
(...skipping 266 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
328 return channel_->SetRtpSendParameters(ssrc, parameters); | 329 return channel_->SetRtpSendParameters(ssrc, parameters); |
329 } | 330 } |
330 | 331 |
331 void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { | 332 void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) { |
332 cricket::AudioSendParameters send_parameters; | 333 cricket::AudioSendParameters send_parameters; |
333 send_parameters.codecs.push_back(codec); | 334 send_parameters.codecs.push_back(codec); |
334 send_parameters.max_bandwidth_bps = bitrate; | 335 send_parameters.max_bandwidth_bps = bitrate; |
335 SetSendParameters(send_parameters); | 336 SetSendParameters(send_parameters); |
336 } | 337 } |
337 | 338 |
338 void CheckSendCodec(int32_t ssrc, | 339 void CheckSendCodecBitrate(int32_t ssrc, |
339 const char expected_name[], | 340 const char expected_name[], |
340 int expected_channels, | 341 int expected_bitrate) { |
341 int expected_bitrate) { | 342 const auto& spec = GetSendStreamConfig(ssrc).send_codec_spec; |
342 const auto& codec = GetSendStreamConfig(ssrc).send_codec_spec.codec_inst; | 343 EXPECT_EQ(expected_name, spec->format.name); |
343 EXPECT_STREQ(expected_name, codec.plname); | 344 EXPECT_EQ(expected_bitrate, spec->target_bitrate_bps); |
344 EXPECT_EQ(expected_channels, codec.channels); | |
345 EXPECT_EQ(expected_bitrate, codec.rate); | |
346 } | 345 } |
347 | 346 |
348 int GetOpusMaxPlaybackRate(int32_t ssrc) { | 347 rtc::Optional<int> GetCodecBitrate(int32_t ssrc) { |
349 return GetSendStreamConfig(ssrc).send_codec_spec.opus_max_playback_rate; | 348 return GetSendStreamConfig(ssrc).send_codec_spec->target_bitrate_bps; |
350 } | |
351 | |
352 bool GetOpusDtx(int32_t ssrc) { | |
353 return GetSendStreamConfig(ssrc).send_codec_spec.enable_opus_dtx; | |
354 } | |
355 | |
356 bool GetCodecFec(int32_t ssrc) { | |
357 return GetSendStreamConfig(ssrc).send_codec_spec.enable_codec_fec; | |
358 } | |
359 | |
360 int GetCodecBitrate(int32_t ssrc) { | |
361 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.rate; | |
362 } | |
363 | |
364 int GetCodecPacSize(int32_t ssrc) { | |
365 return GetSendStreamConfig(ssrc).send_codec_spec.codec_inst.pacsize; | |
366 } | 349 } |
367 | 350 |
368 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { | 351 const rtc::Optional<std::string>& GetAudioNetworkAdaptorConfig(int32_t ssrc) { |
369 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; | 352 return GetSendStreamConfig(ssrc).audio_network_adaptor_config; |
370 } | 353 } |
371 | 354 |
372 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, | 355 void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec, |
373 int global_max, | 356 int global_max, |
374 int stream_max, | 357 int stream_max, |
375 bool expected_result, | 358 bool expected_result, |
(...skipping 308 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
684 GetRecvStreamConfig(kSsrcX); | 667 GetRecvStreamConfig(kSsrcX); |
685 EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc); | 668 EXPECT_EQ(kSsrcX, config.rtp.remote_ssrc); |
686 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); | 669 EXPECT_EQ(0xFA17FA17, config.rtp.local_ssrc); |
687 EXPECT_FALSE(config.rtp.transport_cc); | 670 EXPECT_FALSE(config.rtp.transport_cc); |
688 EXPECT_EQ(0u, config.rtp.extensions.size()); | 671 EXPECT_EQ(0u, config.rtp.extensions.size()); |
689 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), | 672 EXPECT_EQ(static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_), |
690 config.rtcp_send_transport); | 673 config.rtcp_send_transport); |
691 EXPECT_EQ("", config.sync_group); | 674 EXPECT_EQ("", config.sync_group); |
692 } | 675 } |
693 | 676 |
694 // Tests that the list of supported codecs is created properly and ordered | |
695 // correctly (such that opus appears first). | |
696 // TODO(ossu): This test should move into a separate builtin audio codecs | |
697 // module. | |
698 TEST_F(WebRtcVoiceEngineTestFake, CodecOrder) { | |
699 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | |
700 ASSERT_FALSE(codecs.empty()); | |
701 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); | |
702 EXPECT_EQ(48000, codecs[0].clockrate); | |
703 EXPECT_EQ(2, codecs[0].channels); | |
704 EXPECT_EQ(64000, codecs[0].bitrate); | |
705 } | |
706 | |
707 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { | 677 TEST_F(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) { |
708 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); | 678 const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs(); |
709 bool opus_found = false; | 679 bool opus_found = false; |
710 for (cricket::AudioCodec codec : codecs) { | 680 for (cricket::AudioCodec codec : codecs) { |
711 if (codec.name == "opus") { | 681 if (codec.name == "opus") { |
712 EXPECT_TRUE(HasTransportCc(codec)); | 682 EXPECT_TRUE(HasTransportCc(codec)); |
713 opus_found = true; | 683 opus_found = true; |
714 } | 684 } |
715 } | 685 } |
716 EXPECT_TRUE(opus_found); | 686 EXPECT_TRUE(opus_found); |
717 } | 687 } |
718 | 688 |
719 // Tests that we can find codecs by name or id, and that we interpret the | |
720 // clockrate and bitrate fields properly. | |
721 TEST_F(WebRtcVoiceEngineTestFake, FindCodec) { | |
722 cricket::AudioCodec codec; | |
723 webrtc::CodecInst codec_inst; | |
724 // Find PCMU with explicit clockrate and bitrate. | |
725 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kPcmuCodec, &codec_inst)); | |
726 // Find ISAC with explicit clockrate and 0 bitrate. | |
727 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kIsacCodec, &codec_inst)); | |
728 // Find telephone-event with explicit clockrate and 0 bitrate. | |
729 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec1, | |
730 &codec_inst)); | |
731 // Find telephone-event with explicit clockrate and 0 bitrate. | |
732 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kTelephoneEventCodec2, | |
733 &codec_inst)); | |
734 // Find ISAC with a different payload id. | |
735 codec = kIsacCodec; | |
736 codec.id = 127; | |
737 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
738 EXPECT_EQ(codec.id, codec_inst.pltype); | |
739 // Find PCMU with a 0 clockrate. | |
740 codec = kPcmuCodec; | |
741 codec.clockrate = 0; | |
742 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
743 EXPECT_EQ(codec.id, codec_inst.pltype); | |
744 EXPECT_EQ(8000, codec_inst.plfreq); | |
745 // Find PCMU with a 0 bitrate. | |
746 codec = kPcmuCodec; | |
747 codec.bitrate = 0; | |
748 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
749 EXPECT_EQ(codec.id, codec_inst.pltype); | |
750 EXPECT_EQ(64000, codec_inst.rate); | |
751 // Find ISAC with an explicit bitrate. | |
752 codec = kIsacCodec; | |
753 codec.bitrate = 32000; | |
754 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(codec, &codec_inst)); | |
755 EXPECT_EQ(codec.id, codec_inst.pltype); | |
756 EXPECT_EQ(32000, codec_inst.rate); | |
757 } | |
758 | |
759 // Test that we set our inbound codecs properly, including changing PT. | 689 // Test that we set our inbound codecs properly, including changing PT. |
760 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { | 690 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecs) { |
761 EXPECT_TRUE(SetupChannel()); | 691 EXPECT_TRUE(SetupChannel()); |
762 cricket::AudioRecvParameters parameters; | 692 cricket::AudioRecvParameters parameters; |
763 parameters.codecs.push_back(kIsacCodec); | 693 parameters.codecs.push_back(kIsacCodec); |
764 parameters.codecs.push_back(kPcmuCodec); | 694 parameters.codecs.push_back(kPcmuCodec); |
765 parameters.codecs.push_back(kTelephoneEventCodec1); | 695 parameters.codecs.push_back(kTelephoneEventCodec1); |
766 parameters.codecs.push_back(kTelephoneEventCodec2); | 696 parameters.codecs.push_back(kTelephoneEventCodec2); |
767 parameters.codecs[0].id = 106; // collide with existing CN 32k | 697 parameters.codecs[0].id = 106; // collide with existing CN 32k |
768 parameters.codecs[2].id = 126; | 698 parameters.codecs[2].id = 126; |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
812 // Test that we can decode OPUS without stereo parameters. | 742 // Test that we can decode OPUS without stereo parameters. |
813 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { | 743 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpusNoStereo) { |
814 EXPECT_TRUE(SetupChannel()); | 744 EXPECT_TRUE(SetupChannel()); |
815 cricket::AudioRecvParameters parameters; | 745 cricket::AudioRecvParameters parameters; |
816 parameters.codecs.push_back(kIsacCodec); | 746 parameters.codecs.push_back(kIsacCodec); |
817 parameters.codecs.push_back(kPcmuCodec); | 747 parameters.codecs.push_back(kPcmuCodec); |
818 parameters.codecs.push_back(kOpusCodec); | 748 parameters.codecs.push_back(kOpusCodec); |
819 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 749 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
820 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 750 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
821 int channel_num = voe_.GetLastChannel(); | 751 int channel_num = voe_.GetLastChannel(); |
822 webrtc::CodecInst opus; | 752 webrtc::CodecInst opus = kExpectedOpusCodecInst; |
823 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); | |
824 // Even without stereo parameters, recv codecs still specify channels = 2. | 753 // Even without stereo parameters, recv codecs still specify channels = 2. |
825 EXPECT_EQ(2, opus.channels); | |
826 EXPECT_EQ(111, opus.pltype); | |
827 EXPECT_STREQ("opus", opus.plname); | |
828 opus.pltype = 0; | |
829 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, opus)); | 754 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num, opus)); |
830 EXPECT_EQ(111, opus.pltype); | 755 EXPECT_EQ(111, opus.pltype); |
831 } | 756 } |
832 | 757 |
833 // Test that we can decode OPUS with stereo = 0. | 758 // Test that we can decode OPUS with stereo = 0. |
834 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { | 759 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus0Stereo) { |
835 EXPECT_TRUE(SetupChannel()); | 760 EXPECT_TRUE(SetupChannel()); |
836 cricket::AudioRecvParameters parameters; | 761 cricket::AudioRecvParameters parameters; |
837 parameters.codecs.push_back(kIsacCodec); | 762 parameters.codecs.push_back(kIsacCodec); |
838 parameters.codecs.push_back(kPcmuCodec); | 763 parameters.codecs.push_back(kPcmuCodec); |
839 parameters.codecs.push_back(kOpusCodec); | 764 parameters.codecs.push_back(kOpusCodec); |
840 parameters.codecs[2].params["stereo"] = "0"; | 765 parameters.codecs[2].params["stereo"] = "0"; |
841 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 766 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
842 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 767 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
843 int channel_num2 = voe_.GetLastChannel(); | 768 int channel_num2 = voe_.GetLastChannel(); |
844 webrtc::CodecInst opus; | 769 webrtc::CodecInst opus = kExpectedOpusCodecInst; |
845 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); | |
846 // Even when stereo is off, recv codecs still specify channels = 2. | 770 // Even when stereo is off, recv codecs still specify channels = 2. |
847 EXPECT_EQ(2, opus.channels); | |
848 EXPECT_EQ(111, opus.pltype); | |
849 EXPECT_STREQ("opus", opus.plname); | |
850 opus.pltype = 0; | |
851 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); | 771 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); |
852 EXPECT_EQ(111, opus.pltype); | 772 EXPECT_EQ(111, opus.pltype); |
853 } | 773 } |
854 | 774 |
855 // Test that we can decode OPUS with stereo = 1. | 775 // Test that we can decode OPUS with stereo = 1. |
856 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { | 776 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithOpus1Stereo) { |
857 EXPECT_TRUE(SetupChannel()); | 777 EXPECT_TRUE(SetupChannel()); |
858 cricket::AudioRecvParameters parameters; | 778 cricket::AudioRecvParameters parameters; |
859 parameters.codecs.push_back(kIsacCodec); | 779 parameters.codecs.push_back(kIsacCodec); |
860 parameters.codecs.push_back(kPcmuCodec); | 780 parameters.codecs.push_back(kPcmuCodec); |
861 parameters.codecs.push_back(kOpusCodec); | 781 parameters.codecs.push_back(kOpusCodec); |
862 parameters.codecs[2].params["stereo"] = "1"; | 782 parameters.codecs[2].params["stereo"] = "1"; |
863 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 783 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
864 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 784 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
865 int channel_num2 = voe_.GetLastChannel(); | 785 int channel_num2 = voe_.GetLastChannel(); |
866 webrtc::CodecInst opus; | 786 webrtc::CodecInst opus = kExpectedOpusCodecInst; |
867 cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &opus); | |
868 EXPECT_EQ(2, opus.channels); | |
869 EXPECT_EQ(111, opus.pltype); | |
870 EXPECT_STREQ("opus", opus.plname); | |
871 opus.pltype = 0; | |
872 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); | 787 EXPECT_EQ(0, voe_.GetRecPayloadType(channel_num2, opus)); |
873 EXPECT_EQ(111, opus.pltype); | 788 EXPECT_EQ(111, opus.pltype); |
874 } | 789 } |
875 | 790 |
876 // Test that changes to recv codecs are applied to all streams. | 791 // Test that changes to recv codecs are applied to all streams. |
877 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { | 792 TEST_F(WebRtcVoiceEngineTestFake, SetRecvCodecsWithMultipleStreams) { |
878 EXPECT_TRUE(SetupChannel()); | 793 EXPECT_TRUE(SetupChannel()); |
879 cricket::AudioRecvParameters parameters; | 794 cricket::AudioRecvParameters parameters; |
880 parameters.codecs.push_back(kIsacCodec); | 795 parameters.codecs.push_back(kIsacCodec); |
881 parameters.codecs.push_back(kPcmuCodec); | 796 parameters.codecs.push_back(kPcmuCodec); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
941 EXPECT_TRUE(SetupRecvStream()); | 856 EXPECT_TRUE(SetupRecvStream()); |
942 cricket::AudioRecvParameters parameters; | 857 cricket::AudioRecvParameters parameters; |
943 parameters.codecs.push_back(kIsacCodec); | 858 parameters.codecs.push_back(kIsacCodec); |
944 parameters.codecs.push_back(kCn16000Codec); | 859 parameters.codecs.push_back(kCn16000Codec); |
945 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 860 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
946 channel_->SetPlayout(true); | 861 channel_->SetPlayout(true); |
947 | 862 |
948 parameters.codecs.push_back(kOpusCodec); | 863 parameters.codecs.push_back(kOpusCodec); |
949 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 864 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
950 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); | 865 EXPECT_TRUE(GetRecvStream(kSsrcX).started()); |
951 webrtc::CodecInst gcodec; | |
952 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst(kOpusCodec, &gcodec)); | |
953 EXPECT_EQ(kOpusCodec.id, gcodec.pltype); | |
954 } | 866 } |
955 | 867 |
956 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { | 868 TEST_F(WebRtcVoiceEngineTestFake, SetSendBandwidthAuto) { |
957 EXPECT_TRUE(SetupSendStream()); | 869 EXPECT_TRUE(SetupSendStream()); |
958 | 870 |
959 // 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 |
960 // value. autobw is enabled for the following tests because the target | 872 // value. autobw is enabled for the following tests because the target |
961 // bitrate is <= 0. | 873 // bitrate is <= 0. |
962 | 874 |
963 // ISAC, default bitrate == 32000. | 875 // ISAC, default bitrate == 32000. |
964 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); | 876 TestMaxSendBandwidth(kIsacCodec, 0, true, 32000); |
965 | 877 |
966 // PCMU, default bitrate == 64000. | 878 // PCMU, default bitrate == 64000. |
967 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); | 879 TestMaxSendBandwidth(kPcmuCodec, -1, true, 64000); |
968 | 880 |
969 // opus, default bitrate == 64000. | 881 // opus, default bitrate == 32000 in mono. |
970 TestMaxSendBandwidth(kOpusCodec, -1, true, 64000); | 882 TestMaxSendBandwidth(kOpusCodec, -1, true, 32000); |
971 } | 883 } |
972 | 884 |
973 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { | 885 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCaller) { |
974 EXPECT_TRUE(SetupSendStream()); | 886 EXPECT_TRUE(SetupSendStream()); |
975 | 887 |
976 // Test that the bitrate of a multi-rate codec is always the maximum. | |
977 | |
978 // ISAC, default bitrate == 32000. | 888 // ISAC, default bitrate == 32000. |
979 TestMaxSendBandwidth(kIsacCodec, 40000, true, 40000); | |
980 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); | 889 TestMaxSendBandwidth(kIsacCodec, 16000, true, 16000); |
981 // Rates above the max (56000) should be capped. | 890 // Rates above the max (56000) should be capped. |
982 TestMaxSendBandwidth(kIsacCodec, 100000, true, 56000); | 891 TestMaxSendBandwidth(kIsacCodec, 100000, true, 32000); |
983 | 892 |
984 // opus, default bitrate == 64000. | 893 // opus, default bitrate == 64000. |
985 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); | 894 TestMaxSendBandwidth(kOpusCodec, 96000, true, 96000); |
986 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); | 895 TestMaxSendBandwidth(kOpusCodec, 48000, true, 48000); |
987 // Rates above the max (510000) should be capped. | 896 // Rates above the max (510000) should be capped. |
988 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); | 897 TestMaxSendBandwidth(kOpusCodec, 600000, true, 510000); |
989 } | 898 } |
990 | 899 |
991 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { | 900 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthFixedRateAsCaller) { |
992 EXPECT_TRUE(SetupSendStream()); | 901 EXPECT_TRUE(SetupSendStream()); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1035 send_parameters_.max_bandwidth_bps = 128; | 944 send_parameters_.max_bandwidth_bps = 128; |
1036 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); | 945 EXPECT_FALSE(channel_->SetSendParameters(send_parameters_)); |
1037 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | 946 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); |
1038 } | 947 } |
1039 | 948 |
1040 // Test that the per-stream bitrate limit and the global | 949 // Test that the per-stream bitrate limit and the global |
1041 // bitrate limit both apply. | 950 // bitrate limit both apply. |
1042 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { | 951 TEST_F(WebRtcVoiceEngineTestFake, SetMaxBitratePerStream) { |
1043 EXPECT_TRUE(SetupSendStream()); | 952 EXPECT_TRUE(SetupSendStream()); |
1044 | 953 |
1045 // opus, default bitrate == 64000. | 954 // opus, default bitrate == 32000. |
1046 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 64000); | 955 SetAndExpectMaxBitrate(kOpusCodec, 0, 0, true, 32000); |
1047 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); | 956 SetAndExpectMaxBitrate(kOpusCodec, 48000, 0, true, 48000); |
1048 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); | 957 SetAndExpectMaxBitrate(kOpusCodec, 48000, 64000, true, 48000); |
1049 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); | 958 SetAndExpectMaxBitrate(kOpusCodec, 64000, 48000, true, 48000); |
1050 | 959 |
1051 // CBR codecs allow both maximums to exceed the bitrate. | 960 // CBR codecs allow both maximums to exceed the bitrate. |
1052 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); | 961 SetAndExpectMaxBitrate(kPcmuCodec, 0, 0, true, 64000); |
1053 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); | 962 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 0, true, 64000); |
1054 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); | 963 SetAndExpectMaxBitrate(kPcmuCodec, 0, 64001, true, 64000); |
1055 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); | 964 SetAndExpectMaxBitrate(kPcmuCodec, 64001, 64001, true, 64000); |
1056 | 965 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1121 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { | 1030 TEST_F(WebRtcVoiceEngineTestFake, RtpParametersArePerStream) { |
1122 SetupForMultiSendStream(); | 1031 SetupForMultiSendStream(); |
1123 // Create send streams. | 1032 // Create send streams. |
1124 for (uint32_t ssrc : kSsrcs4) { | 1033 for (uint32_t ssrc : kSsrcs4) { |
1125 EXPECT_TRUE( | 1034 EXPECT_TRUE( |
1126 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); | 1035 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(ssrc))); |
1127 } | 1036 } |
1128 // 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 |
1129 // 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 |
1130 // (still subject to the global limit). | 1039 // (still subject to the global limit). |
1131 SetGlobalMaxBitrate(kOpusCodec, 64000); | 1040 SetGlobalMaxBitrate(kOpusCodec, 32000); |
1132 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 48000)); | 1041 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[0], 24000)); |
1133 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 96000)); | 1042 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[1], 48000)); |
1134 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); | 1043 EXPECT_TRUE(SetMaxBitrateForStream(kSsrcs4[2], -1)); |
1135 | 1044 |
1136 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1045 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1137 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[1])); | 1046 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[1])); |
1138 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1047 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1139 | 1048 |
1140 // Remove the global cap; the streams should switch to their respective | 1049 // Remove the global cap; the streams should switch to their respective |
1141 // 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.) |
1142 SetGlobalMaxBitrate(kOpusCodec, -1); | 1051 SetGlobalMaxBitrate(kOpusCodec, -1); |
1143 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[0])); | 1052 EXPECT_EQ(24000, GetCodecBitrate(kSsrcs4[0])); |
1144 EXPECT_EQ(96000, GetCodecBitrate(kSsrcs4[1])); | 1053 EXPECT_EQ(48000, GetCodecBitrate(kSsrcs4[1])); |
1145 EXPECT_EQ(64000, GetCodecBitrate(kSsrcs4[2])); | 1054 EXPECT_EQ(32000, GetCodecBitrate(kSsrcs4[2])); |
1146 } | 1055 } |
1147 | 1056 |
1148 // Test that GetRtpSendParameters returns the currently configured codecs. | 1057 // Test that GetRtpSendParameters returns the currently configured codecs. |
1149 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { | 1058 TEST_F(WebRtcVoiceEngineTestFake, GetRtpSendParametersCodecs) { |
1150 EXPECT_TRUE(SetupSendStream()); | 1059 EXPECT_TRUE(SetupSendStream()); |
1151 cricket::AudioSendParameters parameters; | 1060 cricket::AudioSendParameters parameters; |
1152 parameters.codecs.push_back(kIsacCodec); | 1061 parameters.codecs.push_back(kIsacCodec); |
1153 parameters.codecs.push_back(kPcmuCodec); | 1062 parameters.codecs.push_back(kPcmuCodec); |
1154 SetSendParameters(parameters); | 1063 SetSendParameters(parameters); |
1155 | 1064 |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1231 | 1140 |
1232 // Test that we apply codecs properly. | 1141 // Test that we apply codecs properly. |
1233 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { | 1142 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) { |
1234 EXPECT_TRUE(SetupSendStream()); | 1143 EXPECT_TRUE(SetupSendStream()); |
1235 cricket::AudioSendParameters parameters; | 1144 cricket::AudioSendParameters parameters; |
1236 parameters.codecs.push_back(kIsacCodec); | 1145 parameters.codecs.push_back(kIsacCodec); |
1237 parameters.codecs.push_back(kPcmuCodec); | 1146 parameters.codecs.push_back(kPcmuCodec); |
1238 parameters.codecs.push_back(kCn8000Codec); | 1147 parameters.codecs.push_back(kCn8000Codec); |
1239 parameters.codecs[0].id = 96; | 1148 parameters.codecs[0].id = 96; |
1240 parameters.codecs[0].bitrate = 48000; | 1149 parameters.codecs[0].bitrate = 48000; |
1241 const int initial_num = call_.GetNumCreatedSendStreams(); | |
1242 SetSendParameters(parameters); | 1150 SetSendParameters(parameters); |
1243 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1151 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1244 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1152 EXPECT_EQ(96, send_codec_spec.payload_type); |
1245 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1153 // EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); |
1246 EXPECT_EQ(48000, send_codec_spec.codec_inst.rate); | 1154 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
1247 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1155 EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000); |
1248 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1156 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
1249 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | 1157 // EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); |
1250 EXPECT_FALSE(channel_->CanInsertDtmf()); | 1158 EXPECT_FALSE(channel_->CanInsertDtmf()); |
1251 } | 1159 } |
1252 | 1160 |
1253 // Test that VoE Channel doesn't call SetSendCodec again if same codec is tried | 1161 // Test that WebRtcVoiceEngine reconfigures, rather than recreates its |
1254 // to apply. | 1162 // AudioSendStream. |
1255 TEST_F(WebRtcVoiceEngineTestFake, DontResetSetSendCodec) { | 1163 TEST_F(WebRtcVoiceEngineTestFake, DontRecreateSendStream) { |
ossu
2017/04/04 15:36:38
Also added an AudioSendStream test to check that t
| |
1256 EXPECT_TRUE(SetupSendStream()); | 1164 EXPECT_TRUE(SetupSendStream()); |
1257 cricket::AudioSendParameters parameters; | 1165 cricket::AudioSendParameters parameters; |
1258 parameters.codecs.push_back(kIsacCodec); | 1166 parameters.codecs.push_back(kIsacCodec); |
1259 parameters.codecs.push_back(kPcmuCodec); | 1167 parameters.codecs.push_back(kPcmuCodec); |
1260 parameters.codecs.push_back(kCn8000Codec); | 1168 parameters.codecs.push_back(kCn8000Codec); |
1261 parameters.codecs[0].id = 96; | 1169 parameters.codecs[0].id = 96; |
1262 parameters.codecs[0].bitrate = 48000; | 1170 parameters.codecs[0].bitrate = 48000; |
1263 const int initial_num = call_.GetNumCreatedSendStreams(); | 1171 const int initial_num = call_.GetNumCreatedSendStreams(); |
1264 SetSendParameters(parameters); | 1172 SetSendParameters(parameters); |
1265 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1173 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1266 // Calling SetSendCodec again with same codec which is already set. | 1174 // Calling SetSendCodec again with same codec which is already set. |
1267 // In this case media channel shouldn't send codec to VoE. | 1175 // In this case media channel shouldn't send codec to VoE. |
1268 SetSendParameters(parameters); | 1176 SetSendParameters(parameters); |
1269 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | 1177 EXPECT_EQ(initial_num, call_.GetNumCreatedSendStreams()); |
1270 } | 1178 } |
1271 | 1179 |
1272 // Verify that G722 is set with 16000 samples per second to WebRTC. | 1180 // TODO(ossu): Move these tests into tests for Audio{Encoder,Decoder}Opus or, |
1273 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecG722) { | 1181 // possibly, BuiltinAudio{Encoder,Decoder}Factory; this depends on where we move |
1274 EXPECT_TRUE(SetupSendStream()); | 1182 // validation. |
1275 cricket::AudioSendParameters parameters; | |
1276 parameters.codecs.push_back(kG722CodecSdp); | |
1277 SetSendParameters(parameters); | |
1278 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | |
1279 EXPECT_STREQ("G722", gcodec.plname); | |
1280 EXPECT_EQ(1, gcodec.channels); | |
1281 EXPECT_EQ(16000, gcodec.plfreq); | |
1282 } | |
1283 | 1183 |
1284 // Test that if clockrate is not 48000 for opus, we fail. | 1184 // Test that if clockrate is not 48000 for opus, we fail. |
1285 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { | 1185 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBadClockrate) { |
1286 EXPECT_TRUE(SetupSendStream()); | 1186 EXPECT_TRUE(SetupSendStream()); |
1287 cricket::AudioSendParameters parameters; | 1187 cricket::AudioSendParameters parameters; |
1288 parameters.codecs.push_back(kOpusCodec); | 1188 parameters.codecs.push_back(kOpusCodec); |
1289 parameters.codecs[0].bitrate = 0; | 1189 parameters.codecs[0].bitrate = 0; |
1290 parameters.codecs[0].clockrate = 50000; | 1190 parameters.codecs[0].clockrate = 50000; |
1291 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1191 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1292 } | 1192 } |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1337 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { | 1237 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusBad1Channel1Stereo) { |
1338 EXPECT_TRUE(SetupSendStream()); | 1238 EXPECT_TRUE(SetupSendStream()); |
1339 cricket::AudioSendParameters parameters; | 1239 cricket::AudioSendParameters parameters; |
1340 parameters.codecs.push_back(kOpusCodec); | 1240 parameters.codecs.push_back(kOpusCodec); |
1341 parameters.codecs[0].bitrate = 0; | 1241 parameters.codecs[0].bitrate = 0; |
1342 parameters.codecs[0].channels = 1; | 1242 parameters.codecs[0].channels = 1; |
1343 parameters.codecs[0].params["stereo"] = "1"; | 1243 parameters.codecs[0].params["stereo"] = "1"; |
1344 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1244 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
1345 } | 1245 } |
1346 | 1246 |
1347 // Test that with bitrate=0 and no stereo, | 1247 // Test that with bitrate=0 and no stereo, bitrate is 32000. |
1348 // channels and bitrate are 1 and 32000. | |
1349 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { | 1248 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0BitrateNoStereo) { |
1350 EXPECT_TRUE(SetupSendStream()); | 1249 EXPECT_TRUE(SetupSendStream()); |
1351 cricket::AudioSendParameters parameters; | 1250 cricket::AudioSendParameters parameters; |
1352 parameters.codecs.push_back(kOpusCodec); | 1251 parameters.codecs.push_back(kOpusCodec); |
1353 parameters.codecs[0].bitrate = 0; | 1252 parameters.codecs[0].bitrate = 0; |
1354 SetSendParameters(parameters); | 1253 SetSendParameters(parameters); |
1355 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1254 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1356 } | 1255 } |
1357 | 1256 |
1358 // Test that with bitrate=0 and stereo=0, | 1257 // Test that with bitrate=0 and stereo=0, bitrate is 32000. |
1359 // channels and bitrate are 1 and 32000. | |
1360 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { | 1258 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate0Stereo) { |
1361 EXPECT_TRUE(SetupSendStream()); | 1259 EXPECT_TRUE(SetupSendStream()); |
1362 cricket::AudioSendParameters parameters; | 1260 cricket::AudioSendParameters parameters; |
1363 parameters.codecs.push_back(kOpusCodec); | 1261 parameters.codecs.push_back(kOpusCodec); |
1364 parameters.codecs[0].bitrate = 0; | 1262 parameters.codecs[0].bitrate = 0; |
1365 parameters.codecs[0].params["stereo"] = "0"; | 1263 parameters.codecs[0].params["stereo"] = "0"; |
1366 SetSendParameters(parameters); | 1264 SetSendParameters(parameters); |
1367 CheckSendCodec(kSsrcX, "opus", 1, 32000); | 1265 CheckSendCodecBitrate(kSsrcX, "opus", 32000); |
1368 } | 1266 } |
1369 | 1267 |
1370 // Test that with bitrate=invalid and stereo=0, | 1268 // Test that with bitrate=invalid and stereo=0, bitrate is 32000. |
1371 // channels and bitrate are 1 and 32000. | |
1372 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { | 1269 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate0Stereo) { |
1373 EXPECT_TRUE(SetupSendStream()); | 1270 EXPECT_TRUE(SetupSendStream()); |
1374 cricket::AudioSendParameters parameters; | 1271 cricket::AudioSendParameters parameters; |
1375 parameters.codecs.push_back(kOpusCodec); | 1272 parameters.codecs.push_back(kOpusCodec); |
1376 parameters.codecs[0].params["stereo"] = "0"; | 1273 parameters.codecs[0].params["stereo"] = "0"; |
1377 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1274 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1378 parameters.codecs[0].bitrate = 5999; | 1275 parameters.codecs[0].bitrate = 5999; |
1379 SetSendParameters(parameters); | 1276 SetSendParameters(parameters); |
1380 CheckSendCodec(kSsrcX, "opus", 1, 6000); | 1277 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1381 | 1278 |
1382 parameters.codecs[0].bitrate = 510001; | 1279 parameters.codecs[0].bitrate = 510001; |
1383 SetSendParameters(parameters); | 1280 SetSendParameters(parameters); |
1384 CheckSendCodec(kSsrcX, "opus", 1, 510000); | 1281 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1385 } | 1282 } |
1386 | 1283 |
1387 // Test that with bitrate=0 and stereo=1, | 1284 // Test that with bitrate=0 and stereo=1, bitrate is 64000. |
1388 // channels and bitrate are 2 and 64000. | |
1389 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { | 1285 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGood0Bitrate1Stereo) { |
1390 EXPECT_TRUE(SetupSendStream()); | 1286 EXPECT_TRUE(SetupSendStream()); |
1391 cricket::AudioSendParameters parameters; | 1287 cricket::AudioSendParameters parameters; |
1392 parameters.codecs.push_back(kOpusCodec); | 1288 parameters.codecs.push_back(kOpusCodec); |
1393 parameters.codecs[0].bitrate = 0; | 1289 parameters.codecs[0].bitrate = 0; |
1394 parameters.codecs[0].params["stereo"] = "1"; | 1290 parameters.codecs[0].params["stereo"] = "1"; |
1395 SetSendParameters(parameters); | 1291 SetSendParameters(parameters); |
1396 CheckSendCodec(kSsrcX, "opus", 2, 64000); | 1292 CheckSendCodecBitrate(kSsrcX, "opus", 64000); |
1397 } | 1293 } |
1398 | 1294 |
1399 // Test that with bitrate=invalid and stereo=1, | 1295 // Test that with bitrate=invalid and stereo=1, bitrate is 64000. |
1400 // channels and bitrate are 2 and 64000. | |
1401 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { | 1296 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodXBitrate1Stereo) { |
1402 EXPECT_TRUE(SetupSendStream()); | 1297 EXPECT_TRUE(SetupSendStream()); |
1403 cricket::AudioSendParameters parameters; | 1298 cricket::AudioSendParameters parameters; |
1404 parameters.codecs.push_back(kOpusCodec); | 1299 parameters.codecs.push_back(kOpusCodec); |
1405 parameters.codecs[0].params["stereo"] = "1"; | 1300 parameters.codecs[0].params["stereo"] = "1"; |
1406 // bitrate that's out of the range between 6000 and 510000 will be clamped. | 1301 // bitrate that's out of the range between 6000 and 510000 will be clamped. |
1407 parameters.codecs[0].bitrate = 5999; | 1302 parameters.codecs[0].bitrate = 5999; |
1408 SetSendParameters(parameters); | 1303 SetSendParameters(parameters); |
1409 CheckSendCodec(kSsrcX, "opus", 2, 6000); | 1304 CheckSendCodecBitrate(kSsrcX, "opus", 6000); |
1410 | 1305 |
1411 parameters.codecs[0].bitrate = 510001; | 1306 parameters.codecs[0].bitrate = 510001; |
1412 SetSendParameters(parameters); | 1307 SetSendParameters(parameters); |
1413 CheckSendCodec(kSsrcX, "opus", 2, 510000); | 1308 CheckSendCodecBitrate(kSsrcX, "opus", 510000); |
1414 } | 1309 } |
1415 | 1310 |
1416 // Test that with bitrate=N and stereo unset, | 1311 // Test that with bitrate=N and stereo unset, bitrate is N. |
1417 // channels and bitrate are 1 and N. | |
1418 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { | 1312 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoStereo) { |
1419 EXPECT_TRUE(SetupSendStream()); | 1313 EXPECT_TRUE(SetupSendStream()); |
1420 cricket::AudioSendParameters parameters; | 1314 cricket::AudioSendParameters parameters; |
1421 parameters.codecs.push_back(kOpusCodec); | 1315 parameters.codecs.push_back(kOpusCodec); |
1422 parameters.codecs[0].bitrate = 96000; | 1316 parameters.codecs[0].bitrate = 96000; |
1423 SetSendParameters(parameters); | 1317 SetSendParameters(parameters); |
1424 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1318 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1425 EXPECT_EQ(111, gcodec.pltype); | 1319 EXPECT_EQ(111, spec.payload_type); |
1426 EXPECT_EQ(96000, gcodec.rate); | 1320 EXPECT_EQ(96000, spec.target_bitrate_bps); |
1427 EXPECT_STREQ("opus", gcodec.plname); | 1321 EXPECT_EQ("opus", spec.format.name); |
1428 EXPECT_EQ(1, gcodec.channels); | 1322 EXPECT_EQ(2, spec.format.num_channels); |
1429 EXPECT_EQ(48000, gcodec.plfreq); | 1323 EXPECT_EQ(48000, spec.format.clockrate_hz); |
1430 } | 1324 } |
1431 | 1325 |
1432 // Test that with bitrate=N and stereo=0, | 1326 // Test that with bitrate=N and stereo=0, bitrate is N. |
1433 // channels and bitrate are 1 and N. | |
1434 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { | 1327 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate0Stereo) { |
1435 EXPECT_TRUE(SetupSendStream()); | 1328 EXPECT_TRUE(SetupSendStream()); |
1436 cricket::AudioSendParameters parameters; | 1329 cricket::AudioSendParameters parameters; |
1437 parameters.codecs.push_back(kOpusCodec); | 1330 parameters.codecs.push_back(kOpusCodec); |
1438 parameters.codecs[0].bitrate = 30000; | 1331 parameters.codecs[0].bitrate = 30000; |
1439 parameters.codecs[0].params["stereo"] = "0"; | 1332 parameters.codecs[0].params["stereo"] = "0"; |
1440 SetSendParameters(parameters); | 1333 SetSendParameters(parameters); |
1441 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1334 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1442 } | 1335 } |
1443 | 1336 |
1444 // Test that with bitrate=N and without any parameters, | 1337 // Test that with bitrate=N and without any parameters, bitrate is N. |
1445 // channels and bitrate are 1 and N. | |
1446 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { | 1338 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrateNoParameters) { |
1447 EXPECT_TRUE(SetupSendStream()); | 1339 EXPECT_TRUE(SetupSendStream()); |
1448 cricket::AudioSendParameters parameters; | 1340 cricket::AudioSendParameters parameters; |
1449 parameters.codecs.push_back(kOpusCodec); | 1341 parameters.codecs.push_back(kOpusCodec); |
1450 parameters.codecs[0].bitrate = 30000; | 1342 parameters.codecs[0].bitrate = 30000; |
1451 SetSendParameters(parameters); | 1343 SetSendParameters(parameters); |
1452 CheckSendCodec(kSsrcX, "opus", 1, 30000); | 1344 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1453 } | 1345 } |
1454 | 1346 |
1455 // Test that with bitrate=N and stereo=1, | 1347 // Test that with bitrate=N and stereo=1, bitrate is N. |
1456 // channels and bitrate are 2 and N. | |
1457 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { | 1348 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusGoodNBitrate1Stereo) { |
1458 EXPECT_TRUE(SetupSendStream()); | 1349 EXPECT_TRUE(SetupSendStream()); |
1459 cricket::AudioSendParameters parameters; | 1350 cricket::AudioSendParameters parameters; |
1460 parameters.codecs.push_back(kOpusCodec); | 1351 parameters.codecs.push_back(kOpusCodec); |
1461 parameters.codecs[0].bitrate = 30000; | 1352 parameters.codecs[0].bitrate = 30000; |
1462 parameters.codecs[0].params["stereo"] = "1"; | 1353 parameters.codecs[0].params["stereo"] = "1"; |
1463 SetSendParameters(parameters); | 1354 SetSendParameters(parameters); |
1464 CheckSendCodec(kSsrcX, "opus", 2, 30000); | 1355 CheckSendCodecBitrate(kSsrcX, "opus", 30000); |
1465 } | |
1466 | |
1467 // Test that bitrate will be overridden by the "maxaveragebitrate" parameter. | |
1468 // Also test that the "maxaveragebitrate" can't be set to values outside the | |
1469 // range of 6000 and 510000 | |
1470 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusMaxAverageBitrate) { | |
1471 EXPECT_TRUE(SetupSendStream()); | |
1472 cricket::AudioSendParameters parameters; | |
1473 parameters.codecs.push_back(kOpusCodec); | |
1474 parameters.codecs[0].bitrate = 30000; | |
1475 // Ignore if less than 6000. | |
1476 parameters.codecs[0].params["maxaveragebitrate"] = "5999"; | |
1477 SetSendParameters(parameters); | |
1478 EXPECT_EQ(6000, GetCodecBitrate(kSsrcX)); | |
1479 | |
1480 // Ignore if larger than 510000. | |
1481 parameters.codecs[0].params["maxaveragebitrate"] = "510001"; | |
1482 SetSendParameters(parameters); | |
1483 EXPECT_EQ(510000, GetCodecBitrate(kSsrcX)); | |
1484 | |
1485 parameters.codecs[0].params["maxaveragebitrate"] = "200000"; | |
1486 SetSendParameters(parameters); | |
1487 EXPECT_EQ(200000, GetCodecBitrate(kSsrcX)); | |
1488 } | 1356 } |
1489 | 1357 |
1490 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { | 1358 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithBitrates) { |
1491 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", | 1359 SetSendCodecsShouldWorkForBitrates("100", 100000, "150", 150000, "200", |
1492 200000); | 1360 200000); |
1493 } | 1361 } |
1494 | 1362 |
1495 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { | 1363 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithHighMaxBitrate) { |
1496 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); | 1364 SetSendCodecsShouldWorkForBitrates("", 0, "", -1, "10000", 10000000); |
1497 } | 1365 } |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1613 cricket::kParamValueEmpty)); | 1481 cricket::kParamValueEmpty)); |
1614 SetSendParameters(parameters); | 1482 SetSendParameters(parameters); |
1615 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); | 1483 EXPECT_EQ(kRtpHistoryMs, GetSendStreamConfig(kSsrcX).rtp.nack.rtp_history_ms); |
1616 | 1484 |
1617 EXPECT_TRUE(AddRecvStream(kSsrcY)); | 1485 EXPECT_TRUE(AddRecvStream(kSsrcY)); |
1618 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); | 1486 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms); |
1619 EXPECT_TRUE(AddRecvStream(kSsrcZ)); | 1487 EXPECT_TRUE(AddRecvStream(kSsrcZ)); |
1620 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); | 1488 EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcZ).rtp.nack.rtp_history_ms); |
1621 } | 1489 } |
1622 | 1490 |
1623 // Test that without useinbandfec, Opus FEC is off. | |
1624 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecNoOpusFec) { | |
1625 EXPECT_TRUE(SetupSendStream()); | |
1626 cricket::AudioSendParameters parameters; | |
1627 parameters.codecs.push_back(kOpusCodec); | |
1628 SetSendParameters(parameters); | |
1629 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1630 } | |
1631 | |
1632 // Test that with useinbandfec=0, Opus FEC is off. | |
1633 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusDisableFec) { | |
1634 EXPECT_TRUE(SetupSendStream()); | |
1635 cricket::AudioSendParameters parameters; | |
1636 parameters.codecs.push_back(kOpusCodec); | |
1637 parameters.codecs[0].bitrate = 0; | |
1638 parameters.codecs[0].params["useinbandfec"] = "0"; | |
1639 SetSendParameters(parameters); | |
1640 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1641 } | |
1642 | |
1643 // Test that with useinbandfec=1, Opus FEC is on. | |
1644 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFec) { | |
1645 EXPECT_TRUE(SetupSendStream()); | |
1646 cricket::AudioSendParameters parameters; | |
1647 parameters.codecs.push_back(kOpusCodec); | |
1648 parameters.codecs[0].bitrate = 0; | |
1649 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1650 SetSendParameters(parameters); | |
1651 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1652 CheckSendCodec(kSsrcX, "opus", 1, 32000); | |
1653 } | |
1654 | |
1655 // Test that with useinbandfec=1, stereo=1, Opus FEC is on. | |
1656 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecOpusEnableFecStereo) { | |
1657 EXPECT_TRUE(SetupSendStream()); | |
1658 cricket::AudioSendParameters parameters; | |
1659 parameters.codecs.push_back(kOpusCodec); | |
1660 parameters.codecs[0].bitrate = 0; | |
1661 parameters.codecs[0].params["stereo"] = "1"; | |
1662 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1663 SetSendParameters(parameters); | |
1664 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1665 CheckSendCodec(kSsrcX, "opus", 2, 64000); | |
1666 } | |
1667 | |
1668 // Test that with non-Opus, codec FEC is off. | |
1669 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacNoFec) { | |
1670 EXPECT_TRUE(SetupSendStream()); | |
1671 cricket::AudioSendParameters parameters; | |
1672 parameters.codecs.push_back(kIsacCodec); | |
1673 SetSendParameters(parameters); | |
1674 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1675 } | |
1676 | |
1677 // Test the with non-Opus, even if useinbandfec=1, FEC is off. | |
1678 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecIsacWithParamNoFec) { | |
1679 EXPECT_TRUE(SetupSendStream()); | |
1680 cricket::AudioSendParameters parameters; | |
1681 parameters.codecs.push_back(kIsacCodec); | |
1682 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1683 SetSendParameters(parameters); | |
1684 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1685 } | |
1686 | |
1687 // Test that Opus FEC status can be changed. | |
1688 TEST_F(WebRtcVoiceEngineTestFake, ChangeOpusFecStatus) { | |
1689 EXPECT_TRUE(SetupSendStream()); | |
1690 cricket::AudioSendParameters parameters; | |
1691 parameters.codecs.push_back(kOpusCodec); | |
1692 SetSendParameters(parameters); | |
1693 EXPECT_FALSE(GetCodecFec(kSsrcX)); | |
1694 | |
1695 parameters.codecs[0].params["useinbandfec"] = "1"; | |
1696 SetSendParameters(parameters); | |
1697 EXPECT_TRUE(GetCodecFec(kSsrcX)); | |
1698 } | |
1699 | |
1700 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { | 1491 TEST_F(WebRtcVoiceEngineTestFake, TransportCcCanBeEnabledAndDisabled) { |
1701 EXPECT_TRUE(SetupChannel()); | 1492 EXPECT_TRUE(SetupChannel()); |
1702 cricket::AudioSendParameters send_parameters; | 1493 cricket::AudioSendParameters send_parameters; |
1703 send_parameters.codecs.push_back(kOpusCodec); | 1494 send_parameters.codecs.push_back(kOpusCodec); |
1704 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); | 1495 EXPECT_TRUE(send_parameters.codecs[0].feedback_params.params().empty()); |
1705 SetSendParameters(send_parameters); | 1496 SetSendParameters(send_parameters); |
1706 | 1497 |
1707 cricket::AudioRecvParameters recv_parameters; | 1498 cricket::AudioRecvParameters recv_parameters; |
1708 recv_parameters.codecs.push_back(kIsacCodec); | 1499 recv_parameters.codecs.push_back(kIsacCodec); |
1709 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 1500 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
1710 EXPECT_TRUE(AddRecvStream(kSsrcX)); | 1501 EXPECT_TRUE(AddRecvStream(kSsrcX)); |
1711 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1502 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1712 EXPECT_FALSE( | 1503 EXPECT_FALSE( |
1713 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1504 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1714 | 1505 |
1715 send_parameters.codecs = engine_->send_codecs(); | 1506 send_parameters.codecs = engine_->send_codecs(); |
1716 SetSendParameters(send_parameters); | 1507 SetSendParameters(send_parameters); |
1717 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); | 1508 ASSERT_TRUE(call_.GetAudioReceiveStream(kSsrcX) != nullptr); |
1718 EXPECT_TRUE( | 1509 EXPECT_TRUE( |
1719 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); | 1510 call_.GetAudioReceiveStream(kSsrcX)->GetConfig().rtp.transport_cc); |
1720 } | 1511 } |
1721 | 1512 |
1722 // Test maxplaybackrate <= 8000 triggers Opus narrow band mode. | |
1723 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateNb) { | |
1724 EXPECT_TRUE(SetupSendStream()); | |
1725 cricket::AudioSendParameters parameters; | |
1726 parameters.codecs.push_back(kOpusCodec); | |
1727 parameters.codecs[0].bitrate = 0; | |
1728 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1729 SetSendParameters(parameters); | |
1730 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1731 EXPECT_EQ(12000, GetCodecBitrate(kSsrcX)); | |
1732 | |
1733 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1734 SetSendParameters(parameters); | |
1735 EXPECT_EQ(24000, GetCodecBitrate(kSsrcX)); | |
1736 } | |
1737 | |
1738 // Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode. | |
1739 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateMb) { | |
1740 EXPECT_TRUE(SetupSendStream()); | |
1741 cricket::AudioSendParameters parameters; | |
1742 parameters.codecs.push_back(kOpusCodec); | |
1743 parameters.codecs[0].bitrate = 0; | |
1744 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8001); | |
1745 SetSendParameters(parameters); | |
1746 EXPECT_EQ(8001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1747 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1748 | |
1749 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1750 SetSendParameters(parameters); | |
1751 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1752 } | |
1753 | |
1754 // Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode. | |
1755 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateWb) { | |
1756 EXPECT_TRUE(SetupSendStream()); | |
1757 cricket::AudioSendParameters parameters; | |
1758 parameters.codecs.push_back(kOpusCodec); | |
1759 parameters.codecs[0].bitrate = 0; | |
1760 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 12001); | |
1761 SetSendParameters(parameters); | |
1762 EXPECT_EQ(12001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1763 EXPECT_EQ(20000, GetCodecBitrate(kSsrcX)); | |
1764 | |
1765 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1766 SetSendParameters(parameters); | |
1767 EXPECT_EQ(40000, GetCodecBitrate(kSsrcX)); | |
1768 } | |
1769 | |
1770 // Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode. | |
1771 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateSwb) { | |
1772 EXPECT_TRUE(SetupSendStream()); | |
1773 cricket::AudioSendParameters parameters; | |
1774 parameters.codecs.push_back(kOpusCodec); | |
1775 parameters.codecs[0].bitrate = 0; | |
1776 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 16001); | |
1777 SetSendParameters(parameters); | |
1778 EXPECT_EQ(16001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1779 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1780 | |
1781 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1782 SetSendParameters(parameters); | |
1783 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1784 } | |
1785 | |
1786 // Test 24000 < maxplaybackrate triggers Opus full band mode. | |
1787 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateFb) { | |
1788 EXPECT_TRUE(SetupSendStream()); | |
1789 cricket::AudioSendParameters parameters; | |
1790 parameters.codecs.push_back(kOpusCodec); | |
1791 parameters.codecs[0].bitrate = 0; | |
1792 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 24001); | |
1793 SetSendParameters(parameters); | |
1794 EXPECT_EQ(24001, GetOpusMaxPlaybackRate(kSsrcX)); | |
1795 EXPECT_EQ(32000, GetCodecBitrate(kSsrcX)); | |
1796 | |
1797 parameters.codecs[0].SetParam(cricket::kCodecParamStereo, "1"); | |
1798 SetSendParameters(parameters); | |
1799 EXPECT_EQ(64000, GetCodecBitrate(kSsrcX)); | |
1800 } | |
1801 | |
1802 // Test Opus that without maxplaybackrate, default playback rate is used. | |
1803 TEST_F(WebRtcVoiceEngineTestFake, DefaultOpusMaxPlaybackRate) { | |
1804 EXPECT_TRUE(SetupSendStream()); | |
1805 cricket::AudioSendParameters parameters; | |
1806 parameters.codecs.push_back(kOpusCodec); | |
1807 SetSendParameters(parameters); | |
1808 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1809 } | |
1810 | |
1811 // Test the with non-Opus, maxplaybackrate has no effect. | |
1812 TEST_F(WebRtcVoiceEngineTestFake, SetNonOpusMaxPlaybackRate) { | |
1813 EXPECT_TRUE(SetupSendStream()); | |
1814 cricket::AudioSendParameters parameters; | |
1815 parameters.codecs.push_back(kIsacCodec); | |
1816 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 32000); | |
1817 SetSendParameters(parameters); | |
1818 EXPECT_EQ(0, GetOpusMaxPlaybackRate(kSsrcX)); | |
1819 } | |
1820 | |
1821 // Test maxplaybackrate can be set on two streams. | |
1822 TEST_F(WebRtcVoiceEngineTestFake, SetOpusMaxPlaybackRateOnTwoStreams) { | |
1823 EXPECT_TRUE(SetupSendStream()); | |
1824 cricket::AudioSendParameters parameters; | |
1825 parameters.codecs.push_back(kOpusCodec); | |
1826 SetSendParameters(parameters); | |
1827 EXPECT_EQ(48000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1828 | |
1829 parameters.codecs[0].SetParam(cricket::kCodecParamMaxPlaybackRate, 8000); | |
1830 SetSendParameters(parameters); | |
1831 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcX)); | |
1832 | |
1833 channel_->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrcY)); | |
1834 EXPECT_EQ(8000, GetOpusMaxPlaybackRate(kSsrcY)); | |
1835 } | |
1836 | |
1837 // Test that with usedtx=0, Opus DTX is off. | |
1838 TEST_F(WebRtcVoiceEngineTestFake, DisableOpusDtxOnOpus) { | |
1839 EXPECT_TRUE(SetupSendStream()); | |
1840 cricket::AudioSendParameters parameters; | |
1841 parameters.codecs.push_back(kOpusCodec); | |
1842 parameters.codecs[0].params["usedtx"] = "0"; | |
1843 SetSendParameters(parameters); | |
1844 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1845 } | |
1846 | |
1847 // Test that with usedtx=1, Opus DTX is on. | |
1848 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpus) { | |
1849 EXPECT_TRUE(SetupSendStream()); | |
1850 cricket::AudioSendParameters parameters; | |
1851 parameters.codecs.push_back(kOpusCodec); | |
1852 parameters.codecs[0].params["usedtx"] = "1"; | |
1853 SetSendParameters(parameters); | |
1854 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1855 } | |
1856 | |
1857 // Test that usedtx=1 works with stereo Opus. | |
1858 TEST_F(WebRtcVoiceEngineTestFake, EnableOpusDtxOnOpusStereo) { | |
1859 EXPECT_TRUE(SetupSendStream()); | |
1860 cricket::AudioSendParameters parameters; | |
1861 parameters.codecs.push_back(kOpusCodec); | |
1862 parameters.codecs[0].params["usedtx"] = "1"; | |
1863 parameters.codecs[0].params["stereo"] = "1"; | |
1864 SetSendParameters(parameters); | |
1865 EXPECT_TRUE(GetOpusDtx(kSsrcX)); | |
1866 } | |
1867 | |
1868 // Test that usedtx=1 does not work with non Opus. | |
1869 TEST_F(WebRtcVoiceEngineTestFake, CannotEnableOpusDtxOnNonOpus) { | |
1870 EXPECT_TRUE(SetupSendStream()); | |
1871 cricket::AudioSendParameters parameters; | |
1872 parameters.codecs.push_back(kIsacCodec); | |
1873 parameters.codecs[0].params["usedtx"] = "1"; | |
1874 SetSendParameters(parameters); | |
1875 EXPECT_FALSE(GetOpusDtx(kSsrcX)); | |
1876 } | |
1877 | |
1878 // Test that we can switch back and forth between Opus and ISAC with CN. | 1513 // Test that we can switch back and forth between Opus and ISAC with CN. |
1879 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { | 1514 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsIsacOpusSwitching) { |
1880 EXPECT_TRUE(SetupSendStream()); | 1515 EXPECT_TRUE(SetupSendStream()); |
1881 | 1516 |
1882 cricket::AudioSendParameters opus_parameters; | 1517 cricket::AudioSendParameters opus_parameters; |
1883 opus_parameters.codecs.push_back(kOpusCodec); | 1518 opus_parameters.codecs.push_back(kOpusCodec); |
1884 SetSendParameters(opus_parameters); | 1519 SetSendParameters(opus_parameters); |
1885 { | 1520 { |
1886 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1521 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1887 EXPECT_EQ(111, gcodec.pltype); | 1522 EXPECT_EQ(111, spec.payload_type); |
1888 EXPECT_STREQ("opus", gcodec.plname); | 1523 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1889 } | 1524 } |
1890 | 1525 |
1891 cricket::AudioSendParameters isac_parameters; | 1526 cricket::AudioSendParameters isac_parameters; |
1892 isac_parameters.codecs.push_back(kIsacCodec); | 1527 isac_parameters.codecs.push_back(kIsacCodec); |
1893 isac_parameters.codecs.push_back(kCn16000Codec); | 1528 isac_parameters.codecs.push_back(kCn16000Codec); |
1894 isac_parameters.codecs.push_back(kOpusCodec); | 1529 isac_parameters.codecs.push_back(kOpusCodec); |
1895 SetSendParameters(isac_parameters); | 1530 SetSendParameters(isac_parameters); |
1896 { | 1531 { |
1897 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1532 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1898 EXPECT_EQ(103, gcodec.pltype); | 1533 EXPECT_EQ(103, spec.payload_type); |
1899 EXPECT_STREQ("ISAC", gcodec.plname); | 1534 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1900 } | 1535 } |
1901 | 1536 |
1902 SetSendParameters(opus_parameters); | 1537 SetSendParameters(opus_parameters); |
1903 { | 1538 { |
1904 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1539 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1905 EXPECT_EQ(111, gcodec.pltype); | 1540 EXPECT_EQ(111, spec.payload_type); |
1906 EXPECT_STREQ("opus", gcodec.plname); | 1541 EXPECT_STRCASEEQ("opus", spec.format.name.c_str()); |
1907 } | 1542 } |
1908 } | 1543 } |
1909 | 1544 |
1910 // Test that we handle various ways of specifying bitrate. | 1545 // Test that we handle various ways of specifying bitrate. |
1911 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { | 1546 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsBitrate) { |
1912 EXPECT_TRUE(SetupSendStream()); | 1547 EXPECT_TRUE(SetupSendStream()); |
1913 cricket::AudioSendParameters parameters; | 1548 cricket::AudioSendParameters parameters; |
1914 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 | 1549 parameters.codecs.push_back(kIsacCodec); // bitrate == 32000 |
1915 SetSendParameters(parameters); | 1550 SetSendParameters(parameters); |
1916 { | 1551 { |
1917 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1552 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1918 EXPECT_EQ(103, gcodec.pltype); | 1553 EXPECT_EQ(103, spec.payload_type); |
1919 EXPECT_STREQ("ISAC", gcodec.plname); | 1554 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1920 EXPECT_EQ(32000, gcodec.rate); | 1555 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1921 } | 1556 } |
1922 | 1557 |
1923 parameters.codecs[0].bitrate = 0; // bitrate == default | 1558 parameters.codecs[0].bitrate = 0; // bitrate == default |
1924 SetSendParameters(parameters); | 1559 SetSendParameters(parameters); |
1925 { | 1560 { |
1926 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1561 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1927 EXPECT_EQ(103, gcodec.pltype); | 1562 EXPECT_EQ(103, spec.payload_type); |
1928 EXPECT_STREQ("ISAC", gcodec.plname); | 1563 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1929 EXPECT_EQ(32000, gcodec.rate); | 1564 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1930 } | 1565 } |
1931 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 | 1566 parameters.codecs[0].bitrate = 28000; // bitrate == 28000 |
1932 SetSendParameters(parameters); | 1567 SetSendParameters(parameters); |
1933 { | 1568 { |
1934 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1569 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1935 EXPECT_EQ(103, gcodec.pltype); | 1570 EXPECT_EQ(103, spec.payload_type); |
1936 EXPECT_STREQ("ISAC", gcodec.plname); | 1571 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
1937 EXPECT_EQ(28000, gcodec.rate); | 1572 EXPECT_EQ(28000, spec.target_bitrate_bps); |
1938 } | 1573 } |
1939 | 1574 |
1940 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 | 1575 parameters.codecs[0] = kPcmuCodec; // bitrate == 64000 |
1941 SetSendParameters(parameters); | 1576 SetSendParameters(parameters); |
1942 { | 1577 { |
1943 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1578 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1944 EXPECT_EQ(0, gcodec.pltype); | 1579 EXPECT_EQ(0, spec.payload_type); |
1945 EXPECT_STREQ("PCMU", gcodec.plname); | 1580 EXPECT_STRCASEEQ("PCMU", spec.format.name.c_str()); |
1946 EXPECT_EQ(64000, gcodec.rate); | 1581 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1947 } | 1582 } |
1948 | 1583 |
1949 parameters.codecs[0].bitrate = 0; // bitrate == default | 1584 parameters.codecs[0].bitrate = 0; // bitrate == default |
1950 SetSendParameters(parameters); | 1585 SetSendParameters(parameters); |
1951 { | 1586 { |
1952 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1587 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1953 EXPECT_EQ(0, gcodec.pltype); | 1588 EXPECT_EQ(0, spec.payload_type); |
1954 EXPECT_STREQ("PCMU", gcodec.plname); | 1589 EXPECT_STREQ("PCMU", spec.format.name.c_str()); |
1955 EXPECT_EQ(64000, gcodec.rate); | 1590 EXPECT_EQ(64000, spec.target_bitrate_bps); |
1956 } | 1591 } |
1957 | 1592 |
1958 parameters.codecs[0] = kOpusCodec; | 1593 parameters.codecs[0] = kOpusCodec; |
1959 parameters.codecs[0].bitrate = 0; // bitrate == default | 1594 parameters.codecs[0].bitrate = 0; // bitrate == default |
1960 SetSendParameters(parameters); | 1595 SetSendParameters(parameters); |
1961 { | 1596 { |
1962 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1597 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
1963 EXPECT_EQ(111, gcodec.pltype); | 1598 EXPECT_EQ(111, spec.payload_type); |
1964 EXPECT_STREQ("opus", gcodec.plname); | 1599 EXPECT_STREQ("opus", spec.format.name.c_str()); |
1965 EXPECT_EQ(32000, gcodec.rate); | 1600 EXPECT_EQ(32000, spec.target_bitrate_bps); |
1966 } | 1601 } |
1967 } | 1602 } |
1968 | 1603 |
1604 #if 0 | |
1969 // Test that we could set packet size specified in kCodecParamPTime. | 1605 // Test that we could set packet size specified in kCodecParamPTime. |
1970 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { | 1606 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsPTimeAsPacketSize) { |
1971 EXPECT_TRUE(SetupSendStream()); | 1607 EXPECT_TRUE(SetupSendStream()); |
1972 cricket::AudioSendParameters parameters; | 1608 cricket::AudioSendParameters parameters; |
1973 parameters.codecs.push_back(kOpusCodec); | 1609 parameters.codecs.push_back(kOpusCodec); |
1974 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1610 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1975 SetSendParameters(parameters); | 1611 SetSendParameters(parameters); |
1976 EXPECT_EQ(1920, GetCodecPacSize(kSsrcX)); // Opus gets 40ms. | 1612 EXPECT_EQ(1920, GetCodecPacSize(kSsrcX)); // Opus gets 40ms. |
1977 | 1613 |
1978 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. | 1614 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 5); // Below range. |
1979 SetSendParameters(parameters); | 1615 SetSendParameters(parameters); |
1980 EXPECT_EQ(480, GetCodecPacSize(kSsrcX)); // Opus gets 10ms. | 1616 EXPECT_EQ(480, GetCodecPacSize(kSsrcX)); // Opus gets 10ms. |
1981 | 1617 |
1982 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. | 1618 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 80); // Beyond range. |
1983 SetSendParameters(parameters); | 1619 SetSendParameters(parameters); |
1984 EXPECT_EQ(2880, GetCodecPacSize(kSsrcX)); // Opus gets 60ms. | 1620 EXPECT_EQ(2880, GetCodecPacSize(kSsrcX)); // Opus gets 60ms. |
1985 | 1621 |
1986 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. | 1622 parameters.codecs[0] = kIsacCodec; // Also try Isac, with unsupported size. |
1987 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. | 1623 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); // Within range. |
1988 SetSendParameters(parameters); | 1624 SetSendParameters(parameters); |
1989 EXPECT_EQ(480, GetCodecPacSize( | 1625 EXPECT_EQ(480, GetCodecPacSize( |
1990 kSsrcX)); // Isac gets 30ms as the next smallest value. | 1626 kSsrcX)); // Isac gets 30ms as the next smallest value. |
1991 | 1627 |
1992 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. | 1628 parameters.codecs[0] = kG722CodecSdp; // Try G722 @8kHz as negotiated in SDP. |
1993 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); | 1629 parameters.codecs[0].SetParam(cricket::kCodecParamPTime, 40); |
1994 SetSendParameters(parameters); | 1630 SetSendParameters(parameters); |
1995 EXPECT_EQ(640, GetCodecPacSize( | 1631 EXPECT_EQ(640, GetCodecPacSize( |
1996 kSsrcX)); // G722 gets 40ms @16kHz as defined in VoE. | 1632 kSsrcX)); // G722 gets 40ms @16kHz as defined in VoE. |
1997 } | 1633 } |
1634 #endif | |
1998 | 1635 |
1999 // Test that we fail if no codecs are specified. | 1636 // Test that we fail if no codecs are specified. |
2000 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { | 1637 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsNoCodecs) { |
2001 EXPECT_TRUE(SetupSendStream()); | 1638 EXPECT_TRUE(SetupSendStream()); |
2002 cricket::AudioSendParameters parameters; | 1639 cricket::AudioSendParameters parameters; |
2003 EXPECT_FALSE(channel_->SetSendParameters(parameters)); | 1640 EXPECT_FALSE(channel_->SetSendParameters(parameters)); |
2004 } | 1641 } |
2005 | 1642 |
2006 // Test that we can set send codecs even with telephone-event codec as the first | 1643 // Test that we can set send codecs even with telephone-event codec as the first |
2007 // one on the list. | 1644 // one on the list. |
2008 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { | 1645 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFOnTop) { |
2009 EXPECT_TRUE(SetupSendStream()); | 1646 EXPECT_TRUE(SetupSendStream()); |
2010 cricket::AudioSendParameters parameters; | 1647 cricket::AudioSendParameters parameters; |
2011 parameters.codecs.push_back(kTelephoneEventCodec1); | 1648 parameters.codecs.push_back(kTelephoneEventCodec1); |
2012 parameters.codecs.push_back(kIsacCodec); | 1649 parameters.codecs.push_back(kIsacCodec); |
2013 parameters.codecs.push_back(kPcmuCodec); | 1650 parameters.codecs.push_back(kPcmuCodec); |
2014 parameters.codecs[0].id = 98; // DTMF | 1651 parameters.codecs[0].id = 98; // DTMF |
2015 parameters.codecs[1].id = 96; | 1652 parameters.codecs[1].id = 96; |
2016 SetSendParameters(parameters); | 1653 SetSendParameters(parameters); |
2017 const auto& gcodec = GetSendStreamConfig(kSsrcX).send_codec_spec.codec_inst; | 1654 const auto& spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2018 EXPECT_EQ(96, gcodec.pltype); | 1655 EXPECT_EQ(96, spec.payload_type); |
2019 EXPECT_STREQ("ISAC", gcodec.plname); | 1656 EXPECT_STRCASEEQ("ISAC", spec.format.name.c_str()); |
2020 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1657 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2021 } | 1658 } |
2022 | 1659 |
2023 // Test that payload type range is limited for telephone-event codec. | 1660 // Test that payload type range is limited for telephone-event codec. |
2024 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { | 1661 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsDTMFPayloadTypeOutOfRange) { |
2025 EXPECT_TRUE(SetupSendStream()); | 1662 EXPECT_TRUE(SetupSendStream()); |
2026 cricket::AudioSendParameters parameters; | 1663 cricket::AudioSendParameters parameters; |
2027 parameters.codecs.push_back(kTelephoneEventCodec2); | 1664 parameters.codecs.push_back(kTelephoneEventCodec2); |
2028 parameters.codecs.push_back(kIsacCodec); | 1665 parameters.codecs.push_back(kIsacCodec); |
2029 parameters.codecs[0].id = 0; // DTMF | 1666 parameters.codecs[0].id = 0; // DTMF |
(...skipping 15 matching lines...) Expand all Loading... | |
2045 // one on the list. | 1682 // one on the list. |
2046 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { | 1683 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNOnTop) { |
2047 EXPECT_TRUE(SetupSendStream()); | 1684 EXPECT_TRUE(SetupSendStream()); |
2048 cricket::AudioSendParameters parameters; | 1685 cricket::AudioSendParameters parameters; |
2049 parameters.codecs.push_back(kCn16000Codec); | 1686 parameters.codecs.push_back(kCn16000Codec); |
2050 parameters.codecs.push_back(kIsacCodec); | 1687 parameters.codecs.push_back(kIsacCodec); |
2051 parameters.codecs.push_back(kPcmuCodec); | 1688 parameters.codecs.push_back(kPcmuCodec); |
2052 parameters.codecs[0].id = 98; // wideband CN | 1689 parameters.codecs[0].id = 98; // wideband CN |
2053 parameters.codecs[1].id = 96; | 1690 parameters.codecs[1].id = 96; |
2054 SetSendParameters(parameters); | 1691 SetSendParameters(parameters); |
2055 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1692 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2056 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1693 EXPECT_EQ(96, send_codec_spec.payload_type); |
2057 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1694 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2058 EXPECT_EQ(98, send_codec_spec.cng_payload_type); | 1695 EXPECT_EQ(98, send_codec_spec.cng_payload_type); |
2059 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | 1696 // EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); |
2060 } | 1697 } |
2061 | 1698 |
2062 // Test that we set VAD and DTMF types correctly as caller. | 1699 // Test that we set VAD and DTMF types correctly as caller. |
2063 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { | 1700 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCaller) { |
2064 EXPECT_TRUE(SetupSendStream()); | 1701 EXPECT_TRUE(SetupSendStream()); |
2065 cricket::AudioSendParameters parameters; | 1702 cricket::AudioSendParameters parameters; |
2066 parameters.codecs.push_back(kIsacCodec); | 1703 parameters.codecs.push_back(kIsacCodec); |
2067 parameters.codecs.push_back(kPcmuCodec); | 1704 parameters.codecs.push_back(kPcmuCodec); |
2068 // TODO(juberti): cn 32000 | 1705 // TODO(juberti): cn 32000 |
2069 parameters.codecs.push_back(kCn16000Codec); | 1706 parameters.codecs.push_back(kCn16000Codec); |
2070 parameters.codecs.push_back(kCn8000Codec); | 1707 parameters.codecs.push_back(kCn8000Codec); |
2071 parameters.codecs.push_back(kTelephoneEventCodec1); | 1708 parameters.codecs.push_back(kTelephoneEventCodec1); |
2072 parameters.codecs[0].id = 96; | 1709 parameters.codecs[0].id = 96; |
2073 parameters.codecs[2].id = 97; // wideband CN | 1710 parameters.codecs[2].id = 97; // wideband CN |
2074 parameters.codecs[4].id = 98; // DTMF | 1711 parameters.codecs[4].id = 98; // DTMF |
2075 SetSendParameters(parameters); | 1712 SetSendParameters(parameters); |
2076 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1713 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2077 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1714 EXPECT_EQ(96, send_codec_spec.payload_type); |
2078 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1715 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2079 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1716 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2080 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2081 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1717 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2082 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2083 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1718 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2084 } | 1719 } |
2085 | 1720 |
2086 // Test that we set VAD and DTMF types correctly as callee. | 1721 // Test that we set VAD and DTMF types correctly as callee. |
2087 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1722 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
2088 EXPECT_TRUE(SetupChannel()); | 1723 EXPECT_TRUE(SetupChannel()); |
2089 cricket::AudioSendParameters parameters; | 1724 cricket::AudioSendParameters parameters; |
2090 parameters.codecs.push_back(kIsacCodec); | 1725 parameters.codecs.push_back(kIsacCodec); |
2091 parameters.codecs.push_back(kPcmuCodec); | 1726 parameters.codecs.push_back(kPcmuCodec); |
2092 // TODO(juberti): cn 32000 | 1727 // TODO(juberti): cn 32000 |
2093 parameters.codecs.push_back(kCn16000Codec); | 1728 parameters.codecs.push_back(kCn16000Codec); |
2094 parameters.codecs.push_back(kCn8000Codec); | 1729 parameters.codecs.push_back(kCn8000Codec); |
2095 parameters.codecs.push_back(kTelephoneEventCodec2); | 1730 parameters.codecs.push_back(kTelephoneEventCodec2); |
2096 parameters.codecs[0].id = 96; | 1731 parameters.codecs[0].id = 96; |
2097 parameters.codecs[2].id = 97; // wideband CN | 1732 parameters.codecs[2].id = 97; // wideband CN |
2098 parameters.codecs[4].id = 98; // DTMF | 1733 parameters.codecs[4].id = 98; // DTMF |
2099 SetSendParameters(parameters); | 1734 SetSendParameters(parameters); |
2100 EXPECT_TRUE(channel_->AddSendStream( | 1735 EXPECT_TRUE(channel_->AddSendStream( |
2101 cricket::StreamParams::CreateLegacy(kSsrcX))); | 1736 cricket::StreamParams::CreateLegacy(kSsrcX))); |
2102 | 1737 |
2103 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1738 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2104 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1739 EXPECT_EQ(96, send_codec_spec.payload_type); |
2105 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1740 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2106 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1741 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2107 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2108 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1742 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2109 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2110 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1743 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2111 } | 1744 } |
2112 | 1745 |
2113 // Test that we only apply VAD if we have a CN codec that matches the | 1746 // Test that we only apply VAD if we have a CN codec that matches the |
2114 // send codec clockrate. | 1747 // send codec clockrate. |
2115 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { | 1748 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) { |
2116 EXPECT_TRUE(SetupSendStream()); | 1749 EXPECT_TRUE(SetupSendStream()); |
2117 cricket::AudioSendParameters parameters; | 1750 cricket::AudioSendParameters parameters; |
2118 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1751 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2119 parameters.codecs.push_back(kIsacCodec); | 1752 parameters.codecs.push_back(kIsacCodec); |
2120 parameters.codecs.push_back(kCn16000Codec); | 1753 parameters.codecs.push_back(kCn16000Codec); |
2121 parameters.codecs[1].id = 97; | 1754 parameters.codecs[1].id = 97; |
2122 SetSendParameters(parameters); | 1755 SetSendParameters(parameters); |
2123 { | 1756 { |
2124 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1757 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2125 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1758 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2126 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1759 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2127 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2128 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1760 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2129 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2130 } | 1761 } |
2131 // Set PCMU(8K) and CN(16K). VAD should not be activated. | 1762 // Set PCMU(8K) and CN(16K). VAD should not be activated. |
2132 parameters.codecs[0] = kPcmuCodec; | 1763 parameters.codecs[0] = kPcmuCodec; |
2133 SetSendParameters(parameters); | 1764 SetSendParameters(parameters); |
2134 { | 1765 { |
2135 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1766 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2136 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1767 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2137 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1768 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2138 } | 1769 } |
2139 // Set PCMU(8K) and CN(8K). VAD should be activated. | 1770 // Set PCMU(8K) and CN(8K). VAD should be activated. |
2140 parameters.codecs[1] = kCn8000Codec; | 1771 parameters.codecs[1] = kCn8000Codec; |
2141 SetSendParameters(parameters); | 1772 SetSendParameters(parameters); |
2142 { | 1773 { |
2143 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1774 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2144 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1775 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2145 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1776 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2146 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2147 EXPECT_EQ(13, send_codec_spec.cng_payload_type); | 1777 EXPECT_EQ(13, send_codec_spec.cng_payload_type); |
2148 EXPECT_EQ(webrtc::kFreq8000Hz, send_codec_spec.cng_plfreq); | |
2149 } | 1778 } |
2150 // Set ISAC(16K) and CN(8K). VAD should not be activated. | 1779 // Set ISAC(16K) and CN(8K). VAD should not be activated. |
2151 parameters.codecs[0] = kIsacCodec; | 1780 parameters.codecs[0] = kIsacCodec; |
2152 SetSendParameters(parameters); | 1781 SetSendParameters(parameters); |
2153 { | 1782 { |
2154 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1783 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2155 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1784 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2156 EXPECT_NE(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1785 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2157 } | 1786 } |
2158 } | 1787 } |
2159 | 1788 |
2160 // Test that we perform case-insensitive matching of codec names. | 1789 // Test that we perform case-insensitive matching of codec names. |
2161 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { | 1790 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCaseInsensitive) { |
2162 EXPECT_TRUE(SetupSendStream()); | 1791 EXPECT_TRUE(SetupSendStream()); |
2163 cricket::AudioSendParameters parameters; | 1792 cricket::AudioSendParameters parameters; |
2164 parameters.codecs.push_back(kIsacCodec); | 1793 parameters.codecs.push_back(kIsacCodec); |
2165 parameters.codecs.push_back(kPcmuCodec); | 1794 parameters.codecs.push_back(kPcmuCodec); |
2166 parameters.codecs.push_back(kCn16000Codec); | 1795 parameters.codecs.push_back(kCn16000Codec); |
2167 parameters.codecs.push_back(kCn8000Codec); | 1796 parameters.codecs.push_back(kCn8000Codec); |
2168 parameters.codecs.push_back(kTelephoneEventCodec1); | 1797 parameters.codecs.push_back(kTelephoneEventCodec1); |
2169 parameters.codecs[0].name = "iSaC"; | 1798 parameters.codecs[0].name = "iSaC"; |
2170 parameters.codecs[0].id = 96; | 1799 parameters.codecs[0].id = 96; |
2171 parameters.codecs[2].id = 97; // wideband CN | 1800 parameters.codecs[2].id = 97; // wideband CN |
2172 parameters.codecs[4].id = 98; // DTMF | 1801 parameters.codecs[4].id = 98; // DTMF |
2173 SetSendParameters(parameters); | 1802 SetSendParameters(parameters); |
2174 const auto& send_codec_spec = GetSendStreamConfig(kSsrcX).send_codec_spec; | 1803 const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec; |
2175 EXPECT_EQ(96, send_codec_spec.codec_inst.pltype); | 1804 EXPECT_EQ(96, send_codec_spec.payload_type); |
2176 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1805 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2177 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | 1806 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2178 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | |
2179 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1807 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2180 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2181 EXPECT_TRUE(channel_->CanInsertDtmf()); | 1808 EXPECT_TRUE(channel_->CanInsertDtmf()); |
2182 } | 1809 } |
2183 | 1810 |
2184 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { | 1811 class WebRtcVoiceEngineWithSendSideBweTest : public WebRtcVoiceEngineTestFake { |
2185 public: | 1812 public: |
2186 WebRtcVoiceEngineWithSendSideBweTest() | 1813 WebRtcVoiceEngineWithSendSideBweTest() |
2187 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} | 1814 : WebRtcVoiceEngineTestFake("WebRTC-Audio-SendSideBwe/Enabled/") {} |
2188 }; | 1815 }; |
2189 | 1816 |
2190 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, | 1817 TEST_F(WebRtcVoiceEngineWithSendSideBweTest, |
(...skipping 137 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2328 // Set ISAC(16K) and CN(16K). VAD should be activated. | 1955 // Set ISAC(16K) and CN(16K). VAD should be activated. |
2329 parameters.codecs.push_back(kIsacCodec); | 1956 parameters.codecs.push_back(kIsacCodec); |
2330 parameters.codecs.push_back(kCn16000Codec); | 1957 parameters.codecs.push_back(kCn16000Codec); |
2331 parameters.codecs[1].id = 97; | 1958 parameters.codecs[1].id = 97; |
2332 SetSendParameters(parameters); | 1959 SetSendParameters(parameters); |
2333 | 1960 |
2334 // Verify ISAC and VAD are corrected configured on all send channels. | 1961 // Verify ISAC and VAD are corrected configured on all send channels. |
2335 for (uint32_t ssrc : kSsrcs4) { | 1962 for (uint32_t ssrc : kSsrcs4) { |
2336 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1963 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2337 const auto& send_codec_spec = | 1964 const auto& send_codec_spec = |
2338 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 1965 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2339 EXPECT_STREQ("ISAC", send_codec_spec.codec_inst.plname); | 1966 EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str()); |
2340 EXPECT_EQ(send_codec_spec.codec_inst.plfreq, send_codec_spec.cng_plfreq); | 1967 EXPECT_EQ(1, send_codec_spec.format.num_channels); |
2341 EXPECT_EQ(1, send_codec_spec.codec_inst.channels); | |
2342 EXPECT_EQ(97, send_codec_spec.cng_payload_type); | 1968 EXPECT_EQ(97, send_codec_spec.cng_payload_type); |
2343 EXPECT_EQ(webrtc::kFreq16000Hz, send_codec_spec.cng_plfreq); | |
2344 } | 1969 } |
2345 | 1970 |
2346 // Change to PCMU(8K) and CN(16K). | 1971 // Change to PCMU(8K) and CN(16K). |
2347 parameters.codecs[0] = kPcmuCodec; | 1972 parameters.codecs[0] = kPcmuCodec; |
2348 SetSendParameters(parameters); | 1973 SetSendParameters(parameters); |
2349 for (uint32_t ssrc : kSsrcs4) { | 1974 for (uint32_t ssrc : kSsrcs4) { |
2350 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); | 1975 ASSERT_TRUE(call_.GetAudioSendStream(ssrc) != nullptr); |
2351 const auto& send_codec_spec = | 1976 const auto& send_codec_spec = |
2352 call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; | 1977 *call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec; |
2353 EXPECT_STREQ("PCMU", send_codec_spec.codec_inst.plname); | 1978 EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str()); |
2354 EXPECT_EQ(-1, send_codec_spec.cng_payload_type); | 1979 EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type); |
2355 } | 1980 } |
2356 } | 1981 } |
2357 | 1982 |
2358 // Test we can SetSend on all send streams correctly. | 1983 // Test we can SetSend on all send streams correctly. |
2359 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { | 1984 TEST_F(WebRtcVoiceEngineTestFake, SetSendWithMultipleSendStreams) { |
2360 SetupForMultiSendStream(); | 1985 SetupForMultiSendStream(); |
2361 | 1986 |
2362 // Create the send channels and they should be a "not sending" date. | 1987 // Create the send channels and they should be a "not sending" date. |
2363 for (uint32_t ssrc : kSsrcs4) { | 1988 for (uint32_t ssrc : kSsrcs4) { |
2364 EXPECT_TRUE(channel_->AddSendStream( | 1989 EXPECT_TRUE(channel_->AddSendStream( |
(...skipping 175 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2540 } | 2165 } |
2541 | 2166 |
2542 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { | 2167 TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) { |
2543 EXPECT_TRUE(SetupSendStream()); | 2168 EXPECT_TRUE(SetupSendStream()); |
2544 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2169 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2545 send_parameters_.options.audio_network_adaptor_config = | 2170 send_parameters_.options.audio_network_adaptor_config = |
2546 rtc::Optional<std::string>("1234"); | 2171 rtc::Optional<std::string>("1234"); |
2547 SetSendParameters(send_parameters_); | 2172 SetSendParameters(send_parameters_); |
2548 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2173 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
2549 GetAudioNetworkAdaptorConfig(kSsrcX)); | 2174 GetAudioNetworkAdaptorConfig(kSsrcX)); |
2550 const int initial_num = call_.GetNumCreatedSendStreams(); | |
2551 cricket::AudioOptions options; | 2175 cricket::AudioOptions options; |
2552 options.audio_network_adaptor = rtc::Optional<bool>(false); | 2176 options.audio_network_adaptor = rtc::Optional<bool>(false); |
2553 SetAudioSend(kSsrcX, true, nullptr, &options); | 2177 SetAudioSend(kSsrcX, true, nullptr, &options); |
2554 // AudioSendStream expected to be recreated. | |
2555 EXPECT_EQ(initial_num + 1, call_.GetNumCreatedSendStreams()); | |
2556 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); | 2178 EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX)); |
2557 } | 2179 } |
2558 | 2180 |
2559 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { | 2181 TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) { |
2560 EXPECT_TRUE(SetupSendStream()); | 2182 EXPECT_TRUE(SetupSendStream()); |
2561 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); | 2183 send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true); |
2562 send_parameters_.options.audio_network_adaptor_config = | 2184 send_parameters_.options.audio_network_adaptor_config = |
2563 rtc::Optional<std::string>("1234"); | 2185 rtc::Optional<std::string>("1234"); |
2564 SetSendParameters(send_parameters_); | 2186 SetSendParameters(send_parameters_); |
2565 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, | 2187 EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config, |
(...skipping 1029 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3595 webrtc::RtcEventLogNullImpl event_log; | 3217 webrtc::RtcEventLogNullImpl event_log; |
3596 std::unique_ptr<webrtc::Call> call( | 3218 std::unique_ptr<webrtc::Call> call( |
3597 webrtc::Call::Create(webrtc::Call::Config(&event_log))); | 3219 webrtc::Call::Create(webrtc::Call::Config(&event_log))); |
3598 cricket::VoiceMediaChannel* channel = engine.CreateChannel( | 3220 cricket::VoiceMediaChannel* channel = engine.CreateChannel( |
3599 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); | 3221 call.get(), cricket::MediaConfig(), cricket::AudioOptions()); |
3600 EXPECT_TRUE(channel != nullptr); | 3222 EXPECT_TRUE(channel != nullptr); |
3601 delete channel; | 3223 delete channel; |
3602 } | 3224 } |
3603 } | 3225 } |
3604 | 3226 |
3605 // Tests that the library is configured with the codecs we want. | 3227 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. |
3606 TEST(WebRtcVoiceEngineTest, HasCorrectCodecs) { | 3228 TEST(WebRtcVoiceEngineTest, HasCorrectPayloadTypeMapping) { |
3607 // TODO(ossu): These tests should move into a future "builtin audio codecs" | |
3608 // module. | |
3609 | |
3610 // Check codecs by name. | |
3611 #ifdef WEBRTC_CODEC_OPUS | |
3612 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3613 cricket::AudioCodec(96, "OPUS", 48000, 0, 2), nullptr)); | |
3614 #endif | |
3615 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) | |
3616 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3617 cricket::AudioCodec(96, "ISAC", 16000, 0, 1), nullptr)); | |
3618 #endif | |
3619 #if (defined(WEBRTC_CODEC_ISAC)) | |
3620 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3621 cricket::AudioCodec(96, "ISAC", 32000, 0, 1), nullptr)); | |
3622 #endif | |
3623 #ifdef WEBRTC_CODEC_ILBC | |
3624 // Check that name matching is case-insensitive. | |
3625 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3626 cricket::AudioCodec(96, "ILBC", 8000, 0, 1), nullptr)); | |
3627 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3628 cricket::AudioCodec(96, "iLBC", 8000, 0, 1), nullptr)); | |
3629 #endif | |
3630 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3631 cricket::AudioCodec(96, "CN", 32000, 0, 1), nullptr)); | |
3632 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3633 cricket::AudioCodec(96, "CN", 16000, 0, 1), nullptr)); | |
3634 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3635 cricket::AudioCodec(96, "telephone-event", 8000, 0, 1), nullptr)); | |
3636 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3637 cricket::AudioCodec(96, "telephone-event", 16000, 0, 1), nullptr)); | |
3638 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3639 cricket::AudioCodec(96, "telephone-event", 32000, 0, 1), nullptr)); | |
3640 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3641 cricket::AudioCodec(96, "telephone-event", 48000, 0, 1), nullptr)); | |
3642 // Check codecs with an id by id. | |
3643 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3644 cricket::AudioCodec(0, "", 8000, 0, 1), nullptr)); // PCMU | |
3645 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3646 cricket::AudioCodec(8, "", 8000, 0, 1), nullptr)); // PCMA | |
3647 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3648 cricket::AudioCodec(9, "", 8000, 0, 1), nullptr)); // G722 | |
3649 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3650 cricket::AudioCodec(13, "", 8000, 0, 1), nullptr)); // CN | |
3651 // Check sample/bitrate matching. | |
3652 EXPECT_TRUE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3653 cricket::AudioCodec(0, "PCMU", 8000, 64000, 1), nullptr)); | |
3654 // Check that bad codecs fail. | |
3655 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3656 cricket::AudioCodec(99, "ABCD", 0, 0, 1), nullptr)); | |
3657 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3658 cricket::AudioCodec(88, "", 0, 0, 1), nullptr)); | |
3659 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3660 cricket::AudioCodec(0, "", 0, 0, 2), nullptr)); | |
3661 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3662 cricket::AudioCodec(0, "", 5000, 0, 1), nullptr)); | |
3663 EXPECT_FALSE(cricket::WebRtcVoiceEngine::ToCodecInst( | |
3664 cricket::AudioCodec(0, "", 0, 5000, 1), nullptr)); | |
3665 | |
3666 // Verify the payload id of common audio codecs, including CN, ISAC, and G722. | |
3667 // TODO(ossu): Why are the payload types of codecs with non-static payload | 3229 // TODO(ossu): Why are the payload types of codecs with non-static payload |
3668 // type assignments checked here? It shouldn't really matter. | 3230 // type assignments checked here? It shouldn't really matter. |
3669 cricket::WebRtcVoiceEngine engine( | 3231 cricket::WebRtcVoiceEngine engine( |
3670 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); | 3232 nullptr, webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr); |
3671 for (const cricket::AudioCodec& codec : engine.send_codecs()) { | 3233 for (const cricket::AudioCodec& codec : engine.send_codecs()) { |
3672 if (codec.name == "CN" && codec.clockrate == 16000) { | 3234 auto is_codec = [&codec](const char* name, int clockrate = 0) { |
3235 return STR_CASE_CMP(codec.name.c_str(), name) == 0 && | |
3236 (clockrate == 0 || codec.clockrate == clockrate); | |
3237 }; | |
3238 if (is_codec("CN", 16000)) { | |
3673 EXPECT_EQ(105, codec.id); | 3239 EXPECT_EQ(105, codec.id); |
3674 } else if (codec.name == "CN" && codec.clockrate == 32000) { | 3240 } else if (is_codec("CN", 32000)) { |
3675 EXPECT_EQ(106, codec.id); | 3241 EXPECT_EQ(106, codec.id); |
3676 } else if (codec.name == "ISAC" && codec.clockrate == 16000) { | 3242 } else if (is_codec("ISAC", 16000)) { |
3677 EXPECT_EQ(103, codec.id); | 3243 EXPECT_EQ(103, codec.id); |
3678 } else if (codec.name == "ISAC" && codec.clockrate == 32000) { | 3244 } else if (is_codec("ISAC", 32000)) { |
3679 EXPECT_EQ(104, codec.id); | 3245 EXPECT_EQ(104, codec.id); |
3680 } else if (codec.name == "G722" && codec.clockrate == 8000) { | 3246 } else if (is_codec("G722", 8000)) { |
3681 EXPECT_EQ(9, codec.id); | 3247 EXPECT_EQ(9, codec.id); |
3682 } else if (codec.name == "telephone-event" && codec.clockrate == 8000) { | 3248 } else if (is_codec("telephone-event", 8000)) { |
3683 EXPECT_EQ(126, codec.id); | 3249 EXPECT_EQ(126, codec.id); |
3684 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. | 3250 // TODO(solenberg): 16k, 32k, 48k DTMF should be dynamically assigned. |
3685 // Remove these checks once both send and receive side assigns payload types | 3251 // Remove these checks once both send and receive side assigns payload types |
3686 // dynamically. | 3252 // dynamically. |
3687 } else if (codec.name == "telephone-event" && codec.clockrate == 16000) { | 3253 } else if (is_codec("telephone-event", 16000)) { |
3688 EXPECT_EQ(113, codec.id); | 3254 EXPECT_EQ(113, codec.id); |
3689 } else if (codec.name == "telephone-event" && codec.clockrate == 32000) { | 3255 } else if (is_codec("telephone-event", 32000)) { |
3690 EXPECT_EQ(112, codec.id); | 3256 EXPECT_EQ(112, codec.id); |
3691 } else if (codec.name == "telephone-event" && codec.clockrate == 48000) { | 3257 } else if (is_codec("telephone-event", 48000)) { |
3692 EXPECT_EQ(110, codec.id); | 3258 EXPECT_EQ(110, codec.id); |
3693 } else if (codec.name == "opus") { | 3259 } else if (is_codec("opus")) { |
3694 EXPECT_EQ(111, codec.id); | 3260 EXPECT_EQ(111, codec.id); |
3695 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); | 3261 ASSERT_TRUE(codec.params.find("minptime") != codec.params.end()); |
3696 EXPECT_EQ("10", codec.params.find("minptime")->second); | 3262 EXPECT_EQ("10", codec.params.find("minptime")->second); |
3697 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); | 3263 ASSERT_TRUE(codec.params.find("useinbandfec") != codec.params.end()); |
3698 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); | 3264 EXPECT_EQ("1", codec.params.find("useinbandfec")->second); |
3699 } | 3265 } |
3700 } | 3266 } |
3701 } | 3267 } |
3702 | 3268 |
3703 // Tests that VoE supports at least 32 channels | 3269 // Tests that VoE supports at least 32 channels |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3815 // Without this cast, the comparison turned unsigned and, thus, failed for -1. | 3381 // Without this cast, the comparison turned unsigned and, thus, failed for -1. |
3816 const int num_specs = static_cast<int>(specs.size()); | 3382 const int num_specs = static_cast<int>(specs.size()); |
3817 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); | 3383 EXPECT_GE(find_codec({"cn", 8000, 1}), num_specs); |
3818 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); | 3384 EXPECT_GE(find_codec({"cn", 16000, 1}), num_specs); |
3819 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); | 3385 EXPECT_EQ(find_codec({"cn", 32000, 1}), -1); |
3820 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); | 3386 EXPECT_GE(find_codec({"telephone-event", 8000, 1}), num_specs); |
3821 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); | 3387 EXPECT_GE(find_codec({"telephone-event", 16000, 1}), num_specs); |
3822 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); | 3388 EXPECT_GE(find_codec({"telephone-event", 32000, 1}), num_specs); |
3823 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); | 3389 EXPECT_GE(find_codec({"telephone-event", 48000, 1}), num_specs); |
3824 } | 3390 } |
OLD | NEW |