OLD | NEW |
---|---|
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2008 Google Inc. | 3 * Copyright 2008 Google Inc. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions are met: | 6 * modification, are permitted provided that the following conditions are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright notice, | 8 * 1. Redistributions of source code must retain the above copyright notice, |
9 * this list of conditions and the following disclaimer. | 9 * this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | 10 * 2. Redistributions in binary form must reproduce the above copyright notice, |
11 * this list of conditions and the following disclaimer in the documentation | 11 * this list of conditions and the following disclaimer in the documentation |
12 * and/or other materials provided with the distribution. | 12 * and/or other materials provided with the distribution. |
13 * 3. The name of the author may not be used to endorse or promote products | 13 * 3. The name of the author may not be used to endorse or promote products |
14 * derived from this software without specific prior written permission. | 14 * derived from this software without specific prior written permission. |
15 * | 15 * |
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED | 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO | 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 */ | 26 */ |
27 | 27 |
28 #include "webrtc/base/byteorder.h" | 28 #include "webrtc/base/byteorder.h" |
29 #include "webrtc/base/gunit.h" | 29 #include "webrtc/base/gunit.h" |
30 #include "webrtc/call.h" | |
30 #include "talk/media/base/constants.h" | 31 #include "talk/media/base/constants.h" |
31 #include "talk/media/base/fakemediaengine.h" | 32 #include "talk/media/base/fakemediaengine.h" |
32 #include "talk/media/base/fakemediaprocessor.h" | 33 #include "talk/media/base/fakemediaprocessor.h" |
33 #include "talk/media/base/fakenetworkinterface.h" | 34 #include "talk/media/base/fakenetworkinterface.h" |
34 #include "talk/media/base/fakertp.h" | 35 #include "talk/media/base/fakertp.h" |
35 #include "talk/media/webrtc/fakewebrtccall.h" | 36 #include "talk/media/webrtc/fakewebrtccall.h" |
36 #include "talk/media/webrtc/fakewebrtcvoiceengine.h" | 37 #include "talk/media/webrtc/fakewebrtcvoiceengine.h" |
37 #include "talk/media/webrtc/webrtcvoiceengine.h" | 38 #include "talk/media/webrtc/webrtcvoiceengine.h" |
38 #include "webrtc/p2p/base/fakesession.h" | 39 #include "webrtc/p2p/base/fakesession.h" |
39 #include "talk/session/media/channel.h" | 40 #include "talk/session/media/channel.h" |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
115 cricket::VoiceMediaChannel::Error error() const { | 116 cricket::VoiceMediaChannel::Error error() const { |
116 return error_; | 117 return error_; |
117 } | 118 } |
118 | 119 |
119 private: | 120 private: |
120 uint32 ssrc_; | 121 uint32 ssrc_; |
121 cricket::VoiceMediaChannel::Error error_; | 122 cricket::VoiceMediaChannel::Error error_; |
122 }; | 123 }; |
123 | 124 |
124 WebRtcVoiceEngineTestFake() | 125 WebRtcVoiceEngineTestFake() |
125 : voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)), | 126 : call_(webrtc::Call::Config()), |
127 voe_(kAudioCodecs, ARRAY_SIZE(kAudioCodecs)), | |
126 trace_wrapper_(new FakeVoETraceWrapper()), | 128 trace_wrapper_(new FakeVoETraceWrapper()), |
127 engine_(new FakeVoEWrapper(&voe_), trace_wrapper_), | 129 engine_(new FakeVoEWrapper(&voe_), trace_wrapper_), |
128 channel_(nullptr) { | 130 channel_(nullptr) { |
129 options_conference_.conference_mode.Set(true); | 131 options_conference_.conference_mode.Set(true); |
130 options_adjust_agc_.adjust_agc_delta.Set(-10); | 132 options_adjust_agc_.adjust_agc_delta.Set(-10); |
131 } | 133 } |
132 bool SetupEngineWithoutStream() { | 134 bool SetupEngineWithoutStream() { |
133 if (!engine_.Init(rtc::Thread::Current())) { | 135 if (!engine_.Init(rtc::Thread::Current())) { |
134 return false; | 136 return false; |
135 } | 137 } |
136 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 138 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
137 return (channel_ != nullptr); | 139 return (channel_ != nullptr); |
138 } | 140 } |
139 bool SetupEngine() { | 141 bool SetupEngine() { |
140 if (!SetupEngineWithoutStream()) { | 142 if (!SetupEngineWithoutStream()) { |
141 return false; | 143 return false; |
142 } | 144 } |
143 return channel_->AddSendStream( | 145 return channel_->AddSendStream( |
144 cricket::StreamParams::CreateLegacy(kSsrc1)); | 146 cricket::StreamParams::CreateLegacy(kSsrc1)); |
145 } | 147 } |
146 void SetupForMultiSendStream() { | 148 void SetupForMultiSendStream() { |
(...skipping 12 matching lines...) Expand all Loading... | |
159 rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len); | 161 rtc::Buffer packet(reinterpret_cast<const uint8_t*>(data), len); |
160 channel_->OnPacketReceived(&packet, rtc::PacketTime()); | 162 channel_->OnPacketReceived(&packet, rtc::PacketTime()); |
161 } | 163 } |
162 void TearDown() override { | 164 void TearDown() override { |
163 delete channel_; | 165 delete channel_; |
164 engine_.Terminate(); | 166 engine_.Terminate(); |
165 } | 167 } |
166 | 168 |
167 void TestInsertDtmf(uint32 ssrc, bool caller) { | 169 void TestInsertDtmf(uint32 ssrc, bool caller) { |
168 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 170 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
169 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 171 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
170 EXPECT_TRUE(channel_ != nullptr); | 172 EXPECT_TRUE(channel_ != nullptr); |
171 if (caller) { | 173 if (caller) { |
172 // if this is a caller, local description will be applied and add the | 174 // if this is a caller, local description will be applied and add the |
173 // send stream. | 175 // send stream. |
174 EXPECT_TRUE(channel_->AddSendStream( | 176 EXPECT_TRUE(channel_->AddSendStream( |
175 cricket::StreamParams::CreateLegacy(kSsrc1))); | 177 cricket::StreamParams::CreateLegacy(kSsrc1))); |
176 } | 178 } |
177 int channel_id = voe_.GetLastChannel(); | 179 int channel_id = voe_.GetLastChannel(); |
178 | 180 |
179 // Test we can only InsertDtmf when the other side supports telephone-event. | 181 // Test we can only InsertDtmf when the other side supports telephone-event. |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
318 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); | 320 EXPECT_EQ(id, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); |
319 | 321 |
320 // Ensure all extensions go back off with an empty list. | 322 // Ensure all extensions go back off with an empty list. |
321 extensions.clear(); | 323 extensions.clear(); |
322 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); | 324 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
323 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); | 325 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(channel_num, ext)); |
324 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); | 326 EXPECT_EQ(-1, voe_.GetReceiveRtpExtensionId(new_channel_num, ext)); |
325 } | 327 } |
326 | 328 |
327 protected: | 329 protected: |
330 cricket::FakeCall call_; | |
328 cricket::FakeWebRtcVoiceEngine voe_; | 331 cricket::FakeWebRtcVoiceEngine voe_; |
329 FakeVoETraceWrapper* trace_wrapper_; | 332 FakeVoETraceWrapper* trace_wrapper_; |
330 cricket::WebRtcVoiceEngine engine_; | 333 cricket::WebRtcVoiceEngine engine_; |
331 cricket::VoiceMediaChannel* channel_; | 334 cricket::VoiceMediaChannel* channel_; |
332 | 335 |
333 cricket::AudioOptions options_conference_; | 336 cricket::AudioOptions options_conference_; |
334 cricket::AudioOptions options_adjust_agc_; | 337 cricket::AudioOptions options_adjust_agc_; |
335 }; | 338 }; |
336 | 339 |
337 // Tests that our stub library "works". | 340 // Tests that our stub library "works". |
338 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) { | 341 TEST_F(WebRtcVoiceEngineTestFake, StartupShutdown) { |
339 EXPECT_FALSE(voe_.IsInited()); | 342 EXPECT_FALSE(voe_.IsInited()); |
340 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 343 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
341 EXPECT_TRUE(voe_.IsInited()); | 344 EXPECT_TRUE(voe_.IsInited()); |
342 engine_.Terminate(); | 345 engine_.Terminate(); |
343 EXPECT_FALSE(voe_.IsInited()); | 346 EXPECT_FALSE(voe_.IsInited()); |
344 } | 347 } |
345 | 348 |
346 // Tests that we can create and destroy a channel. | 349 // Tests that we can create and destroy a channel. |
347 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) { | 350 TEST_F(WebRtcVoiceEngineTestFake, CreateChannel) { |
348 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 351 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
349 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 352 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
350 EXPECT_TRUE(channel_ != nullptr); | 353 EXPECT_TRUE(channel_ != nullptr); |
351 } | 354 } |
352 | 355 |
353 // Tests that we properly handle failures in CreateChannel. | 356 // Tests that we properly handle failures in CreateChannel. |
354 TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) { | 357 TEST_F(WebRtcVoiceEngineTestFake, CreateChannelFail) { |
355 voe_.set_fail_create_channel(true); | 358 voe_.set_fail_create_channel(true); |
356 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 359 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
357 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 360 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
358 EXPECT_TRUE(channel_ == nullptr); | 361 EXPECT_TRUE(channel_ == nullptr); |
359 } | 362 } |
360 | 363 |
361 // Tests that the list of supported codecs is created properly and ordered | 364 // Tests that the list of supported codecs is created properly and ordered |
362 // correctly | 365 // correctly |
363 TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) { | 366 TEST_F(WebRtcVoiceEngineTestFake, CodecPreference) { |
364 const std::vector<cricket::AudioCodec>& codecs = engine_.codecs(); | 367 const std::vector<cricket::AudioCodec>& codecs = engine_.codecs(); |
365 ASSERT_FALSE(codecs.empty()); | 368 ASSERT_FALSE(codecs.empty()); |
366 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); | 369 EXPECT_STRCASEEQ("opus", codecs[0].name.c_str()); |
367 EXPECT_EQ(48000, codecs[0].clockrate); | 370 EXPECT_EQ(48000, codecs[0].clockrate); |
(...skipping 288 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
656 TestSendBandwidth(kPcmuCodec, 1, false, 64000); | 659 TestSendBandwidth(kPcmuCodec, 1, false, 64000); |
657 TestSendBandwidth(kPcmuCodec, 128000, true, 64000); | 660 TestSendBandwidth(kPcmuCodec, 128000, true, 64000); |
658 TestSendBandwidth(kPcmuCodec, 32000, false, 64000); | 661 TestSendBandwidth(kPcmuCodec, 32000, false, 64000); |
659 TestSendBandwidth(kPcmuCodec, 64000, true, 64000); | 662 TestSendBandwidth(kPcmuCodec, 64000, true, 64000); |
660 TestSendBandwidth(kPcmuCodec, 63999, false, 64000); | 663 TestSendBandwidth(kPcmuCodec, 63999, false, 64000); |
661 TestSendBandwidth(kPcmuCodec, 64001, true, 64000); | 664 TestSendBandwidth(kPcmuCodec, 64001, true, 64000); |
662 } | 665 } |
663 | 666 |
664 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { | 667 TEST_F(WebRtcVoiceEngineTestFake, SetMaxSendBandwidthMultiRateAsCallee) { |
665 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 668 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
666 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 669 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
667 EXPECT_TRUE(channel_ != nullptr); | 670 EXPECT_TRUE(channel_ != nullptr); |
668 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); | 671 EXPECT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
669 | 672 |
670 int desired_bitrate = 128000; | 673 int desired_bitrate = 128000; |
671 EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate)); | 674 EXPECT_TRUE(channel_->SetMaxSendBandwidth(desired_bitrate)); |
672 | 675 |
673 EXPECT_TRUE(channel_->AddSendStream( | 676 EXPECT_TRUE(channel_->AddSendStream( |
674 cricket::StreamParams::CreateLegacy(kSsrc1))); | 677 cricket::StreamParams::CreateLegacy(kSsrc1))); |
675 | 678 |
676 int channel_num = voe_.GetLastChannel(); | 679 int channel_num = voe_.GetLastChannel(); |
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1030 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1033 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1031 cricket::kParamValueEmpty)); | 1034 cricket::kParamValueEmpty)); |
1032 EXPECT_FALSE(voe_.GetNACK(channel_num)); | 1035 EXPECT_FALSE(voe_.GetNACK(channel_num)); |
1033 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); | 1036 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
1034 EXPECT_TRUE(voe_.GetNACK(channel_num)); | 1037 EXPECT_TRUE(voe_.GetNACK(channel_num)); |
1035 } | 1038 } |
1036 | 1039 |
1037 // Test that we can enable NACK with opus as callee. | 1040 // Test that we can enable NACK with opus as callee. |
1038 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { | 1041 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecEnableNackAsCallee) { |
1039 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 1042 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
1040 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 1043 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
1041 EXPECT_TRUE(channel_ != nullptr); | 1044 EXPECT_TRUE(channel_ != nullptr); |
1042 | 1045 |
1043 int channel_num = voe_.GetLastChannel(); | 1046 int channel_num = voe_.GetLastChannel(); |
1044 std::vector<cricket::AudioCodec> codecs; | 1047 std::vector<cricket::AudioCodec> codecs; |
1045 codecs.push_back(kOpusCodec); | 1048 codecs.push_back(kOpusCodec); |
1046 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, | 1049 codecs[0].AddFeedbackParam(cricket::FeedbackParam(cricket::kRtcpFbParamNack, |
1047 cricket::kParamValueEmpty)); | 1050 cricket::kParamValueEmpty)); |
1048 EXPECT_FALSE(voe_.GetNACK(channel_num)); | 1051 EXPECT_FALSE(voe_.GetNACK(channel_num)); |
1049 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); | 1052 EXPECT_TRUE(channel_->SetSendCodecs(codecs)); |
1050 EXPECT_FALSE(voe_.GetNACK(channel_num)); | 1053 EXPECT_FALSE(voe_.GetNACK(channel_num)); |
(...skipping 559 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1610 EXPECT_TRUE(voe_.GetVAD(channel_num)); | 1613 EXPECT_TRUE(voe_.GetVAD(channel_num)); |
1611 EXPECT_FALSE(voe_.GetRED(channel_num)); | 1614 EXPECT_FALSE(voe_.GetRED(channel_num)); |
1612 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); | 1615 EXPECT_EQ(13, voe_.GetSendCNPayloadType(channel_num, false)); |
1613 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); | 1616 EXPECT_EQ(97, voe_.GetSendCNPayloadType(channel_num, true)); |
1614 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); | 1617 EXPECT_EQ(98, voe_.GetSendTelephoneEventPayloadType(channel_num)); |
1615 } | 1618 } |
1616 | 1619 |
1617 // Test that we set VAD and DTMF types correctly as callee. | 1620 // Test that we set VAD and DTMF types correctly as callee. |
1618 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { | 1621 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNandDTMFAsCallee) { |
1619 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 1622 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
1620 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 1623 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
1621 EXPECT_TRUE(channel_ != nullptr); | 1624 EXPECT_TRUE(channel_ != nullptr); |
1622 | 1625 |
1623 int channel_num = voe_.GetLastChannel(); | 1626 int channel_num = voe_.GetLastChannel(); |
1624 std::vector<cricket::AudioCodec> codecs; | 1627 std::vector<cricket::AudioCodec> codecs; |
1625 codecs.push_back(kIsacCodec); | 1628 codecs.push_back(kIsacCodec); |
1626 codecs.push_back(kPcmuCodec); | 1629 codecs.push_back(kPcmuCodec); |
1627 // TODO(juberti): cn 32000 | 1630 // TODO(juberti): cn 32000 |
1628 codecs.push_back(kCn16000Codec); | 1631 codecs.push_back(kCn16000Codec); |
1629 codecs.push_back(kCn8000Codec); | 1632 codecs.push_back(kCn8000Codec); |
1630 codecs.push_back(kTelephoneEventCodec); | 1633 codecs.push_back(kTelephoneEventCodec); |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1727 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); | 1730 EXPECT_EQ(0, voe_.GetSendCodec(channel_num, gcodec)); |
1728 EXPECT_EQ(96, gcodec.pltype); | 1731 EXPECT_EQ(96, gcodec.pltype); |
1729 EXPECT_STREQ("ISAC", gcodec.plname); | 1732 EXPECT_STREQ("ISAC", gcodec.plname); |
1730 EXPECT_TRUE(voe_.GetRED(channel_num)); | 1733 EXPECT_TRUE(voe_.GetRED(channel_num)); |
1731 EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num)); | 1734 EXPECT_EQ(127, voe_.GetSendREDPayloadType(channel_num)); |
1732 } | 1735 } |
1733 | 1736 |
1734 // Test that we set up RED correctly as callee. | 1737 // Test that we set up RED correctly as callee. |
1735 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) { | 1738 TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsREDAsCallee) { |
1736 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 1739 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
1737 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 1740 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
1738 EXPECT_TRUE(channel_ != nullptr); | 1741 EXPECT_TRUE(channel_ != nullptr); |
1739 | 1742 |
1740 int channel_num = voe_.GetLastChannel(); | 1743 int channel_num = voe_.GetLastChannel(); |
1741 std::vector<cricket::AudioCodec> codecs; | 1744 std::vector<cricket::AudioCodec> codecs; |
1742 codecs.push_back(kRedCodec); | 1745 codecs.push_back(kRedCodec); |
1743 codecs.push_back(kIsacCodec); | 1746 codecs.push_back(kIsacCodec); |
1744 codecs.push_back(kPcmuCodec); | 1747 codecs.push_back(kPcmuCodec); |
1745 codecs[0].id = 127; | 1748 codecs[0].id = 127; |
1746 codecs[0].params[""] = "96/96"; | 1749 codecs[0].params[""] = "96/96"; |
1747 codecs[1].id = 96; | 1750 codecs[1].id = 96; |
(...skipping 668 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2416 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); | 2419 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2))); |
2417 int channel_num2 = voe_.GetLastChannel(); | 2420 int channel_num2 = voe_.GetLastChannel(); |
2418 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc)); | 2421 EXPECT_EQ(0, voe_.GetLocalSSRC(channel_num2, send_ssrc)); |
2419 EXPECT_EQ(kSsrc1, send_ssrc); | 2422 EXPECT_EQ(kSsrc1, send_ssrc); |
2420 } | 2423 } |
2421 | 2424 |
2422 // Test that the local SSRC is the same on sending and receiving channels if the | 2425 // Test that the local SSRC is the same on sending and receiving channels if the |
2423 // receive channel is created before the send channel. | 2426 // receive channel is created before the send channel. |
2424 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) { | 2427 TEST_F(WebRtcVoiceEngineTestFake, SetSendSsrcAfterCreatingReceiveChannel) { |
2425 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); | 2428 EXPECT_TRUE(engine_.Init(rtc::Thread::Current())); |
2426 channel_ = engine_.CreateChannel(cricket::AudioOptions()); | 2429 channel_ = engine_.CreateChannel(&call_, cricket::AudioOptions()); |
2427 EXPECT_TRUE(channel_->SetOptions(options_conference_)); | 2430 EXPECT_TRUE(channel_->SetOptions(options_conference_)); |
2428 | 2431 |
2429 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); | 2432 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); |
2430 int receive_channel_num = voe_.GetLastChannel(); | 2433 int receive_channel_num = voe_.GetLastChannel(); |
2431 EXPECT_TRUE(channel_->AddSendStream( | 2434 EXPECT_TRUE(channel_->AddSendStream( |
2432 cricket::StreamParams::CreateLegacy(1234))); | 2435 cricket::StreamParams::CreateLegacy(1234))); |
2433 int send_channel_num = voe_.GetLastChannel(); | 2436 int send_channel_num = voe_.GetLastChannel(); |
2434 | 2437 |
2435 unsigned int ssrc = 0; | 2438 unsigned int ssrc = 0; |
2436 EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc)); | 2439 EXPECT_EQ(0, voe_.GetLocalSSRC(send_channel_num, ssrc)); |
(...skipping 549 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2986 EXPECT_EQ(0, voe_.GetAgcConfig(config)); | 2989 EXPECT_EQ(0, voe_.GetAgcConfig(config)); |
2987 EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv); | 2990 EXPECT_EQ(set_config.targetLeveldBOv, config.targetLeveldBOv); |
2988 EXPECT_EQ(set_config.digitalCompressionGaindB, | 2991 EXPECT_EQ(set_config.digitalCompressionGaindB, |
2989 config.digitalCompressionGaindB); | 2992 config.digitalCompressionGaindB); |
2990 EXPECT_EQ(set_config.limiterEnable, config.limiterEnable); | 2993 EXPECT_EQ(set_config.limiterEnable, config.limiterEnable); |
2991 } | 2994 } |
2992 | 2995 |
2993 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { | 2996 TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) { |
2994 EXPECT_TRUE(SetupEngine()); | 2997 EXPECT_TRUE(SetupEngine()); |
2995 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel1( | 2998 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel1( |
2996 engine_.CreateChannel(cricket::AudioOptions())); | 2999 engine_.CreateChannel(&call_, cricket::AudioOptions())); |
2997 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel2( | 3000 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel2( |
2998 engine_.CreateChannel(cricket::AudioOptions())); | 3001 engine_.CreateChannel(&call_, cricket::AudioOptions())); |
2999 | 3002 |
3000 // Have to add a stream to make SetSend work. | 3003 // Have to add a stream to make SetSend work. |
3001 cricket::StreamParams stream1; | 3004 cricket::StreamParams stream1; |
3002 stream1.ssrcs.push_back(1); | 3005 stream1.ssrcs.push_back(1); |
3003 channel1->AddSendStream(stream1); | 3006 channel1->AddSendStream(stream1); |
3004 cricket::StreamParams stream2; | 3007 cricket::StreamParams stream2; |
3005 stream2.ssrcs.push_back(2); | 3008 stream2.ssrcs.push_back(2); |
3006 channel2->AddSendStream(stream2); | 3009 channel2->AddSendStream(stream2); |
3007 | 3010 |
3008 // AEC and AGC and NS | 3011 // AEC and AGC and NS |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3106 voe_.GetNsStatus(ns_enabled, ns_mode); | 3109 voe_.GetNsStatus(ns_enabled, ns_mode); |
3107 EXPECT_TRUE(ec_enabled); | 3110 EXPECT_TRUE(ec_enabled); |
3108 EXPECT_FALSE(agc_enabled); | 3111 EXPECT_FALSE(agc_enabled); |
3109 EXPECT_FALSE(ns_enabled); | 3112 EXPECT_FALSE(ns_enabled); |
3110 } | 3113 } |
3111 | 3114 |
3112 // This test verifies DSCP settings are properly applied on voice media channel. | 3115 // This test verifies DSCP settings are properly applied on voice media channel. |
3113 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { | 3116 TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) { |
3114 EXPECT_TRUE(SetupEngine()); | 3117 EXPECT_TRUE(SetupEngine()); |
3115 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel( | 3118 rtc::scoped_ptr<cricket::VoiceMediaChannel> channel( |
3116 engine_.CreateChannel(cricket::AudioOptions())); | 3119 engine_.CreateChannel(&call_, cricket::AudioOptions())); |
3117 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface( | 3120 rtc::scoped_ptr<cricket::FakeNetworkInterface> network_interface( |
3118 new cricket::FakeNetworkInterface); | 3121 new cricket::FakeNetworkInterface); |
3119 channel->SetInterface(network_interface.get()); | 3122 channel->SetInterface(network_interface.get()); |
3120 cricket::AudioOptions options; | 3123 cricket::AudioOptions options; |
3121 options.dscp.Set(true); | 3124 options.dscp.Set(true); |
3122 EXPECT_TRUE(channel->SetOptions(options)); | 3125 EXPECT_TRUE(channel->SetOptions(options)); |
3123 EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp()); | 3126 EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp()); |
3124 // Verify previous value is not modified if dscp option is not set. | 3127 // Verify previous value is not modified if dscp option is not set. |
3125 cricket::AudioOptions options1; | 3128 cricket::AudioOptions options1; |
3126 EXPECT_TRUE(channel->SetOptions(options1)); | 3129 EXPECT_TRUE(channel->SetOptions(options1)); |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3177 | 3180 |
3178 EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1)); | 3181 EXPECT_TRUE(channel_->SetOutputScaling(kSsrc2, 2, 1)); |
3179 channel_id = voe_.GetLastChannel(); | 3182 channel_id = voe_.GetLastChannel(); |
3180 EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale)); | 3183 EXPECT_EQ(0, voe_.GetChannelOutputVolumeScaling(channel_id, scale)); |
3181 EXPECT_EQ(0, voe_.GetOutputVolumePan(channel_id, left, right)); | 3184 EXPECT_EQ(0, voe_.GetOutputVolumePan(channel_id, left, right)); |
3182 EXPECT_DOUBLE_EQ(2, left * scale); | 3185 EXPECT_DOUBLE_EQ(2, left * scale); |
3183 EXPECT_DOUBLE_EQ(1, right * scale); | 3186 EXPECT_DOUBLE_EQ(1, right * scale); |
3184 } | 3187 } |
3185 | 3188 |
3186 TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) { | 3189 TEST_F(WebRtcVoiceEngineTestFake, SetsSyncGroupFromSyncLabel) { |
3187 cricket::FakeCall call((webrtc::Call::Config())); | |
3188 const uint32 kAudioSsrc = 123; | 3190 const uint32 kAudioSsrc = 123; |
3189 const std::string kSyncLabel = "AvSyncLabel"; | 3191 const std::string kSyncLabel = "AvSyncLabel"; |
3190 | 3192 |
3191 EXPECT_TRUE(SetupEngine()); | 3193 EXPECT_TRUE(SetupEngine()); |
3192 cricket::WebRtcVoiceMediaChannel* media_channel = | |
3193 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | |
3194 media_channel->SetCall(&call); | |
3195 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc); | 3194 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kAudioSsrc); |
3196 sp.sync_label = kSyncLabel; | 3195 sp.sync_label = kSyncLabel; |
3197 // Creating two channels to make sure that sync label is set properly for both | 3196 // Creating two channels to make sure that sync label is set properly for both |
3198 // the default voice channel and following ones. | 3197 // the default voice channel and following ones. |
3199 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 3198 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
3200 sp.ssrcs[0] += 1; | 3199 sp.ssrcs[0] += 1; |
3201 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 3200 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
3202 | 3201 |
3203 ASSERT_EQ(2, call.GetAudioReceiveStreams().size()); | 3202 ASSERT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3204 EXPECT_EQ(kSyncLabel, | 3203 EXPECT_EQ(kSyncLabel, |
3205 call.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group) | 3204 call_.GetAudioReceiveStream(kAudioSsrc)->GetConfig().sync_group) |
3206 << "SyncGroup should be set based on sync_label"; | 3205 << "SyncGroup should be set based on sync_label"; |
3207 EXPECT_EQ(kSyncLabel, | 3206 EXPECT_EQ(kSyncLabel, |
3208 call.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group) | 3207 call_.GetAudioReceiveStream(kAudioSsrc + 1)->GetConfig().sync_group) |
3209 << "SyncGroup should be set based on sync_label"; | 3208 << "SyncGroup should be set based on sync_label"; |
3210 | |
3211 media_channel->SetCall(nullptr); | |
3212 } | 3209 } |
3213 | 3210 |
3214 TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) { | 3211 TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) { |
3215 // Test that changing the combined_audio_video_bwe option results in the | 3212 // Test that changing the combined_audio_video_bwe option results in the |
3216 // expected state changes on an associated Call. | 3213 // expected state changes on an associated Call. |
3217 cricket::FakeCall call((webrtc::Call::Config())); | 3214 std::vector<uint32> ssrcs; |
3218 const uint32 kAudioSsrc1 = 223; | 3215 ssrcs.push_back(223); |
3219 const uint32 kAudioSsrc2 = 224; | 3216 ssrcs.push_back(224); |
3220 | 3217 |
3221 EXPECT_TRUE(SetupEngine()); | 3218 EXPECT_TRUE(SetupEngine()); |
3222 cricket::WebRtcVoiceMediaChannel* media_channel = | 3219 cricket::WebRtcVoiceMediaChannel* media_channel = |
3223 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 3220 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
3224 const auto& rtp_extensions = engine_.rtp_header_extensions(); | 3221 for (uint32 ssrc : ssrcs) { |
3225 media_channel->SetRecvRtpHeaderExtensions(rtp_extensions); | 3222 EXPECT_TRUE(media_channel->AddRecvStream( |
3226 media_channel->SetCall(&call); | 3223 cricket::StreamParams::CreateLegacy(ssrc))); |
3227 EXPECT_TRUE(media_channel->AddRecvStream( | 3224 } |
3228 cricket::StreamParams::CreateLegacy(kAudioSsrc1))); | 3225 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3229 EXPECT_TRUE(media_channel->AddRecvStream( | |
3230 cricket::StreamParams::CreateLegacy(kAudioSsrc2))); | |
3231 | 3226 |
3232 // Combined BWE should not be set up yet. | 3227 // Combined BWE should be disabled. |
3233 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | 3228 for (uint32 ssrc : ssrcs) { |
3234 EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1) | 3229 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3235 ->GetConfig() | 3230 EXPECT_NE(nullptr, s); |
3236 .combined_audio_video_bwe); | 3231 EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe); |
3237 EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2) | 3232 } |
3238 ->GetConfig() | |
3239 .combined_audio_video_bwe); | |
3240 | 3233 |
3241 // Enable combined BWE option - now it should be set up. | 3234 // Enable combined BWE option - now it should be set up. |
3242 cricket::AudioOptions options; | 3235 cricket::AudioOptions options; |
3243 options.combined_audio_video_bwe.Set(true); | 3236 options.combined_audio_video_bwe.Set(true); |
3244 EXPECT_TRUE(media_channel->SetOptions(options)); | 3237 EXPECT_TRUE(media_channel->SetOptions(options)); |
3245 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | 3238 for (uint32 ssrc : ssrcs) { |
3246 EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc1) | 3239 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3247 ->GetConfig() | 3240 EXPECT_NE(nullptr, s); |
3248 .combined_audio_video_bwe); | 3241 EXPECT_EQ(true, s->GetConfig().combined_audio_video_bwe); |
3249 EXPECT_TRUE(call.GetAudioReceiveStream(kAudioSsrc2) | 3242 } |
3250 ->GetConfig() | |
3251 .combined_audio_video_bwe); | |
3252 | 3243 |
3253 // Disable combined BWE option - should be disabled again. | 3244 // Disable combined BWE option - should be disabled again. |
3254 options.combined_audio_video_bwe.Set(false); | 3245 options.combined_audio_video_bwe.Set(false); |
3255 EXPECT_TRUE(media_channel->SetOptions(options)); | 3246 EXPECT_TRUE(media_channel->SetOptions(options)); |
3256 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | 3247 for (uint32 ssrc : ssrcs) { |
3257 EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc1) | 3248 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3258 ->GetConfig() | 3249 EXPECT_NE(nullptr, s); |
3259 .combined_audio_video_bwe); | 3250 EXPECT_EQ(false, s->GetConfig().combined_audio_video_bwe); |
3260 EXPECT_FALSE(call.GetAudioReceiveStream(kAudioSsrc2) | 3251 } |
3261 ->GetConfig() | |
3262 .combined_audio_video_bwe); | |
3263 | 3252 |
3264 media_channel->SetCall(nullptr); | 3253 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3265 } | |
3266 | |
3267 TEST_F(WebRtcVoiceEngineTestFake, SetCallConfiguresAudioReceiveChannels) { | |
3268 // Test that calling SetCall() on the voice media channel results in the | |
3269 // expected state changes in Call. | |
3270 cricket::FakeCall call((webrtc::Call::Config())); | |
3271 cricket::FakeCall call2((webrtc::Call::Config())); | |
3272 const uint32 kAudioSsrc1 = 223; | |
3273 const uint32 kAudioSsrc2 = 224; | |
3274 | |
3275 EXPECT_TRUE(SetupEngine()); | |
3276 cricket::WebRtcVoiceMediaChannel* media_channel = | |
3277 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | |
3278 EXPECT_TRUE(media_channel->AddRecvStream( | |
3279 cricket::StreamParams::CreateLegacy(kAudioSsrc1))); | |
3280 EXPECT_TRUE(media_channel->AddRecvStream( | |
3281 cricket::StreamParams::CreateLegacy(kAudioSsrc2))); | |
3282 | |
3283 // Combined BWE should not be set up yet. | |
3284 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3285 | |
3286 // Register - should be enabled. | |
3287 media_channel->SetCall(&call); | |
3288 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | |
3289 EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc1)); | |
3290 EXPECT_NE(nullptr, call.GetAudioReceiveStream(kAudioSsrc2)); | |
3291 | |
3292 // Re-register - should now be enabled on new call. | |
3293 media_channel->SetCall(&call2); | |
3294 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3295 EXPECT_EQ(2, call2.GetAudioReceiveStreams().size()); | |
3296 EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc1)); | |
3297 EXPECT_NE(nullptr, call2.GetAudioReceiveStream(kAudioSsrc2)); | |
3298 | |
3299 // Unregister - should be disabled again. | |
3300 media_channel->SetCall(nullptr); | |
3301 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3302 } | 3254 } |
3303 | 3255 |
3304 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) { | 3256 TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) { |
3305 // Test that adding receive streams after enabling combined bandwidth | 3257 // Test that adding receive streams after enabling combined bandwidth |
3306 // estimation will correctly configure each channel. | 3258 // estimation will correctly configure each channel. |
3307 cricket::FakeCall call((webrtc::Call::Config())); | |
3308 | |
3309 EXPECT_TRUE(SetupEngine()); | 3259 EXPECT_TRUE(SetupEngine()); |
3310 cricket::WebRtcVoiceMediaChannel* media_channel = | 3260 cricket::WebRtcVoiceMediaChannel* media_channel = |
3311 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 3261 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
3312 media_channel->SetCall(&call); | |
3313 cricket::AudioOptions options; | 3262 cricket::AudioOptions options; |
3314 options.combined_audio_video_bwe.Set(true); | 3263 options.combined_audio_video_bwe.Set(true); |
3315 EXPECT_TRUE(media_channel->SetOptions(options)); | 3264 EXPECT_TRUE(media_channel->SetOptions(options)); |
3316 | 3265 |
3317 static const uint32 kSsrcs[] = {1, 2, 3, 4}; | 3266 static const uint32 kSsrcs[] = {1, 2, 3, 4}; |
3318 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) { | 3267 for (unsigned int i = 0; i < ARRAY_SIZE(kSsrcs); ++i) { |
3319 EXPECT_TRUE(media_channel->AddRecvStream( | 3268 EXPECT_TRUE(media_channel->AddRecvStream( |
3320 cricket::StreamParams::CreateLegacy(kSsrcs[i]))); | 3269 cricket::StreamParams::CreateLegacy(kSsrcs[i]))); |
3321 EXPECT_NE(nullptr, call.GetAudioReceiveStream(kSsrcs[i])); | 3270 EXPECT_NE(nullptr, call_.GetAudioReceiveStream(kSsrcs[i])); |
3322 EXPECT_TRUE(call.GetAudioReceiveStream(kSsrcs[i]) | |
3323 ->GetConfig() | |
3324 .combined_audio_video_bwe); | |
3325 } | 3271 } |
3326 EXPECT_EQ(ARRAY_SIZE(kSsrcs), call.GetAudioReceiveStreams().size()); | 3272 EXPECT_EQ(ARRAY_SIZE(kSsrcs), call_.GetAudioReceiveStreams().size()); |
3327 | |
3328 media_channel->SetCall(nullptr); | |
3329 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3330 } | 3273 } |
3331 | 3274 |
3332 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { | 3275 TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) { |
3333 // Test that setting the header extensions results in the expected state | 3276 // Test that setting the header extensions results in the expected state |
3334 // changes on an associated Call. | 3277 // changes on an associated Call. |
3335 cricket::FakeCall call((webrtc::Call::Config())); | |
3336 std::vector<uint32> ssrcs; | 3278 std::vector<uint32> ssrcs; |
3337 ssrcs.push_back(223); | 3279 ssrcs.push_back(223); |
3338 ssrcs.push_back(224); | 3280 ssrcs.push_back(224); |
3339 | 3281 |
3340 EXPECT_TRUE(SetupEngine()); | 3282 EXPECT_TRUE(SetupEngine()); |
3341 cricket::WebRtcVoiceMediaChannel* media_channel = | 3283 cricket::WebRtcVoiceMediaChannel* media_channel = |
3342 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 3284 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
3343 media_channel->SetCall(&call); | 3285 cricket::AudioOptions options; |
3286 options.combined_audio_video_bwe.Set(true); | |
3287 EXPECT_TRUE(media_channel->SetOptions(options)); | |
3344 for (uint32 ssrc : ssrcs) { | 3288 for (uint32 ssrc : ssrcs) { |
3345 EXPECT_TRUE(media_channel->AddRecvStream( | 3289 EXPECT_TRUE(media_channel->AddRecvStream( |
3346 cricket::StreamParams::CreateLegacy(ssrc))); | 3290 cricket::StreamParams::CreateLegacy(ssrc))); |
3347 } | 3291 } |
3348 | 3292 |
3349 // Combined BWE should be set up, but with no configured extensions. | 3293 // Combined BWE should be set up, but with no configured extensions. |
3350 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | 3294 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3351 for (uint32 ssrc : ssrcs) { | 3295 for (uint32 ssrc : ssrcs) { |
3352 const auto* s = call.GetAudioReceiveStream(ssrc); | 3296 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3353 EXPECT_NE(nullptr, s); | 3297 EXPECT_NE(nullptr, s); |
3354 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); | 3298 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); |
3355 } | 3299 } |
3356 | 3300 |
3357 // Set up receive extensions. | 3301 // Set up receive extensions. |
3358 const auto& e_exts = engine_.rtp_header_extensions(); | 3302 const auto& e_exts = engine_.rtp_header_extensions(); |
3359 channel_->SetRecvRtpHeaderExtensions(e_exts); | 3303 channel_->SetRecvRtpHeaderExtensions(e_exts); |
3360 EXPECT_EQ(2, call.GetAudioReceiveStreams().size()); | 3304 EXPECT_EQ(2, call_.GetAudioReceiveStreams().size()); |
3361 for (uint32 ssrc : ssrcs) { | 3305 for (uint32 ssrc : ssrcs) { |
3362 const auto* s = call.GetAudioReceiveStream(ssrc); | 3306 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3363 EXPECT_NE(nullptr, s); | 3307 EXPECT_NE(nullptr, s); |
3364 const auto& s_exts = s->GetConfig().rtp.extensions; | 3308 const auto& s_exts = s->GetConfig().rtp.extensions; |
3365 EXPECT_EQ(e_exts.size(), s_exts.size()); | 3309 EXPECT_EQ(e_exts.size(), s_exts.size()); |
3366 for (const auto& e_ext : e_exts) { | 3310 for (const auto& e_ext : e_exts) { |
3367 for (const auto& s_ext : s_exts) { | 3311 for (const auto& s_ext : s_exts) { |
3368 if (e_ext.id == s_ext.id) { | 3312 if (e_ext.id == s_ext.id) { |
3369 EXPECT_EQ(e_ext.uri, s_ext.name); | 3313 EXPECT_EQ(e_ext.uri, s_ext.name); |
3370 } | 3314 } |
3371 } | 3315 } |
3372 } | 3316 } |
3373 } | 3317 } |
3374 | 3318 |
3375 // Disable receive extensions. | 3319 // Disable receive extensions. |
3376 std::vector<cricket::RtpHeaderExtension> extensions; | 3320 std::vector<cricket::RtpHeaderExtension> extensions; |
3377 channel_->SetRecvRtpHeaderExtensions(extensions); | 3321 channel_->SetRecvRtpHeaderExtensions(extensions); |
3378 for (uint32 ssrc : ssrcs) { | 3322 for (uint32 ssrc : ssrcs) { |
3379 const auto* s = call.GetAudioReceiveStream(ssrc); | 3323 const auto* s = call_.GetAudioReceiveStream(ssrc); |
3380 EXPECT_NE(nullptr, s); | 3324 EXPECT_NE(nullptr, s); |
3381 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); | 3325 EXPECT_EQ(0, s->GetConfig().rtp.extensions.size()); |
3382 } | 3326 } |
3383 | |
3384 media_channel->SetCall(nullptr); | |
3385 } | 3327 } |
3386 | 3328 |
3387 TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) { | 3329 TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) { |
3388 // Test that packets are forwarded to the Call when configured accordingly. | 3330 // Test that packets are forwarded to the Call when configured accordingly. |
3389 cricket::FakeCall call((webrtc::Call::Config())); | |
3390 const uint32 kAudioSsrc = 1; | 3331 const uint32 kAudioSsrc = 1; |
3391 rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame)); | 3332 rtc::Buffer kPcmuPacket(kPcmuFrame, sizeof(kPcmuFrame)); |
3392 static const unsigned char kRtcp[] = { | 3333 static const unsigned char kRtcp[] = { |
3393 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, | 3334 0x80, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, |
3394 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, | 3335 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
3395 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | 3336 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
3396 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 | 3337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
3397 }; | 3338 }; |
3398 rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp)); | 3339 rtc::Buffer kRtcpPacket(kRtcp, sizeof(kRtcp)); |
3399 | 3340 |
3400 EXPECT_TRUE(SetupEngine()); | 3341 EXPECT_TRUE(SetupEngine()); |
3401 cricket::WebRtcVoiceMediaChannel* media_channel = | 3342 cricket::WebRtcVoiceMediaChannel* media_channel = |
3402 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); | 3343 static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_); |
3403 cricket::AudioOptions options; | 3344 cricket::AudioOptions options; |
3404 options.combined_audio_video_bwe.Set(true); | 3345 options.combined_audio_video_bwe.Set(true); |
3405 EXPECT_TRUE(media_channel->SetOptions(options)); | 3346 EXPECT_TRUE(media_channel->SetOptions(options)); |
3406 EXPECT_TRUE(media_channel->AddRecvStream( | 3347 EXPECT_TRUE(media_channel->AddRecvStream( |
3407 cricket::StreamParams::CreateLegacy(kAudioSsrc))); | 3348 cricket::StreamParams::CreateLegacy(kAudioSsrc))); |
3408 | 3349 |
3409 // Call not set on media channel, so no packets can be forwarded. | 3350 EXPECT_EQ(1, call_.GetAudioReceiveStreams().size()); |
3410 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3411 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); | |
3412 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); | |
3413 EXPECT_EQ(0, call.GetAudioReceiveStreams().size()); | |
3414 | |
3415 // Set Call, now there should be a receive stream which is forwarded packets. | |
3416 media_channel->SetCall(&call); | |
3417 EXPECT_EQ(1, call.GetAudioReceiveStreams().size()); | |
3418 const cricket::FakeAudioReceiveStream* s = | 3351 const cricket::FakeAudioReceiveStream* s = |
3419 call.GetAudioReceiveStream(kAudioSsrc); | 3352 call_.GetAudioReceiveStream(kAudioSsrc); |
3420 EXPECT_EQ(0, s->received_packets()); | 3353 EXPECT_EQ(0, s->received_packets()); |
3421 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); | 3354 channel_->OnPacketReceived(&kPcmuPacket, rtc::PacketTime()); |
3422 EXPECT_EQ(1, s->received_packets()); | 3355 EXPECT_EQ(1, s->received_packets()); |
3423 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); | 3356 channel_->OnRtcpReceived(&kRtcpPacket, rtc::PacketTime()); |
3424 EXPECT_EQ(2, s->received_packets()); | 3357 EXPECT_EQ(2, s->received_packets()); |
3425 | |
3426 media_channel->SetCall(nullptr); | |
3427 } | 3358 } |
3428 | 3359 |
3429 // Associate channel should not set on 1:1 call, since the receive channel also | 3360 // Associate channel should not set on 1:1 call, since the receive channel also |
3430 // sends RTCP SR. | 3361 // sends RTCP SR. |
3431 TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelUnset1On1) { | 3362 TEST_F(WebRtcVoiceEngineTestFake, AssociateChannelUnset1On1) { |
3432 EXPECT_TRUE(SetupEngine()); | 3363 EXPECT_TRUE(SetupEngine()); |
3433 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); | 3364 EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(1))); |
3434 int recv_ch = voe_.GetLastChannel(); | 3365 int recv_ch = voe_.GetLastChannel(); |
3435 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1); | 3366 EXPECT_EQ(voe_.GetAssociateSendChannel(recv_ch), -1); |
3436 } | 3367 } |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3503 // don't check the option values here, though. | 3434 // don't check the option values here, though. |
3504 EXPECT_TRUE(options.echo_cancellation.IsSet()); | 3435 EXPECT_TRUE(options.echo_cancellation.IsSet()); |
3505 EXPECT_TRUE(options.auto_gain_control.IsSet()); | 3436 EXPECT_TRUE(options.auto_gain_control.IsSet()); |
3506 EXPECT_TRUE(options.noise_suppression.IsSet()); | 3437 EXPECT_TRUE(options.noise_suppression.IsSet()); |
3507 } | 3438 } |
3508 | 3439 |
3509 // Tests that the library initializes and shuts down properly. | 3440 // Tests that the library initializes and shuts down properly. |
3510 TEST(WebRtcVoiceEngineTest, StartupShutdown) { | 3441 TEST(WebRtcVoiceEngineTest, StartupShutdown) { |
3511 cricket::WebRtcVoiceEngine engine; | 3442 cricket::WebRtcVoiceEngine engine; |
3512 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); | 3443 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); |
3444 rtc::scoped_ptr<webrtc::Call> call( | |
3445 webrtc::Call::Create(webrtc::Call::Config())); | |
3513 cricket::VoiceMediaChannel* channel = | 3446 cricket::VoiceMediaChannel* channel = |
3514 engine.CreateChannel(cricket::AudioOptions()); | 3447 engine.CreateChannel(call.get(), cricket::AudioOptions()); |
3515 EXPECT_TRUE(channel != nullptr); | 3448 EXPECT_TRUE(channel != nullptr); |
3516 delete channel; | 3449 delete channel; |
3517 engine.Terminate(); | 3450 engine.Terminate(); |
3518 | 3451 |
3519 // Reinit to catch regression where VoiceEngineObserver reference is lost | 3452 // Reinit to catch regression where VoiceEngineObserver reference is lost |
3520 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); | 3453 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); |
3521 engine.Terminate(); | 3454 engine.Terminate(); |
3522 } | 3455 } |
3523 | 3456 |
3524 // Tests that the library is configured with the codecs we want. | 3457 // Tests that the library is configured with the codecs we want. |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3598 } | 3531 } |
3599 } | 3532 } |
3600 | 3533 |
3601 engine.Terminate(); | 3534 engine.Terminate(); |
3602 } | 3535 } |
3603 | 3536 |
3604 // Tests that VoE supports at least 32 channels | 3537 // Tests that VoE supports at least 32 channels |
3605 TEST(WebRtcVoiceEngineTest, Has32Channels) { | 3538 TEST(WebRtcVoiceEngineTest, Has32Channels) { |
3606 cricket::WebRtcVoiceEngine engine; | 3539 cricket::WebRtcVoiceEngine engine; |
3607 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); | 3540 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); |
3541 rtc::scoped_ptr<webrtc::Call> call( | |
3542 webrtc::Call::Create(webrtc::Call::Config())); | |
3543 { | |
pbos-webrtc
2015/09/08 14:47:41
Remove {}s ? They're not scoping anything that sho
the sun
2015/09/08 15:21:35
Done.
| |
3544 cricket::VoiceMediaChannel* channels[32]; | |
3545 int num_channels = 0; | |
3608 | 3546 |
3609 cricket::VoiceMediaChannel* channels[32]; | 3547 while (num_channels < ARRAY_SIZE(channels)) { |
3610 int num_channels = 0; | 3548 cricket::VoiceMediaChannel* channel = |
3549 engine.CreateChannel(call.get(), cricket::AudioOptions()); | |
3550 if (!channel) | |
3551 break; | |
3611 | 3552 |
3612 while (num_channels < ARRAY_SIZE(channels)) { | 3553 channels[num_channels++] = channel; |
3613 cricket::VoiceMediaChannel* channel = | 3554 } |
3614 engine.CreateChannel(cricket::AudioOptions()); | |
3615 if (!channel) | |
3616 break; | |
3617 | 3555 |
3618 channels[num_channels++] = channel; | 3556 int expected = ARRAY_SIZE(channels); |
3557 EXPECT_EQ(expected, num_channels); | |
3558 | |
3559 while (num_channels > 0) { | |
3560 delete channels[--num_channels]; | |
3561 } | |
3619 } | 3562 } |
3620 | |
3621 int expected = ARRAY_SIZE(channels); | |
3622 EXPECT_EQ(expected, num_channels); | |
3623 | |
3624 while (num_channels > 0) { | |
3625 delete channels[--num_channels]; | |
3626 } | |
3627 | |
3628 engine.Terminate(); | 3563 engine.Terminate(); |
3629 } | 3564 } |
3630 | 3565 |
3631 // Test that we set our preferred codecs properly. | 3566 // Test that we set our preferred codecs properly. |
3632 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { | 3567 TEST(WebRtcVoiceEngineTest, SetRecvCodecs) { |
3633 cricket::WebRtcVoiceEngine engine; | 3568 cricket::WebRtcVoiceEngine engine; |
3634 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); | 3569 EXPECT_TRUE(engine.Init(rtc::Thread::Current())); |
3635 cricket::WebRtcVoiceMediaChannel channel(&engine); | 3570 rtc::scoped_ptr<webrtc::Call> call( |
3636 EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs())); | 3571 webrtc::Call::Create(webrtc::Call::Config())); |
3572 { | |
3573 cricket::WebRtcVoiceMediaChannel channel(&engine, call.get()); | |
3574 EXPECT_TRUE(channel.SetRecvCodecs(engine.codecs())); | |
3575 } | |
3637 } | 3576 } |
OLD | NEW |