OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2017 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 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 |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include <memory> |
| 12 |
| 13 #include "webrtc/base/gunit.h" |
| 14 #include "webrtc/media/base/fakemediaengine.h" |
| 15 #include "webrtc/ortc/ortcfactory.h" |
| 16 #include "webrtc/ortc/testrtpparameters.h" |
| 17 #include "webrtc/p2p/base/fakepackettransport.h" |
| 18 |
| 19 namespace webrtc { |
| 20 |
| 21 // This test uses fake packet transports and a fake media engine, in order to |
| 22 // test the RtpTransport at only an API level. Any end-to-end test should go in |
| 23 // ortcfactory_integrationtest.cc instead. |
| 24 class RtpTransportTest : public testing::Test { |
| 25 public: |
| 26 RtpTransportTest() { |
| 27 fake_media_engine_ = new cricket::FakeMediaEngine(); |
| 28 // Note: This doesn't need to use fake network classes, since it uses |
| 29 // FakePacketTransports. |
| 30 auto result = OrtcFactory::Create( |
| 31 nullptr, nullptr, nullptr, nullptr, nullptr, |
| 32 std::unique_ptr<cricket::MediaEngineInterface>(fake_media_engine_)); |
| 33 ortc_factory_ = result.MoveValue(); |
| 34 } |
| 35 |
| 36 protected: |
| 37 // Owned by |ortc_factory_|. |
| 38 cricket::FakeMediaEngine* fake_media_engine_; |
| 39 std::unique_ptr<OrtcFactoryInterface> ortc_factory_; |
| 40 }; |
| 41 |
| 42 // Test GetRtpPacketTransport and GetRtcpPacketTransport, with and without RTCP |
| 43 // muxing. |
| 44 TEST_F(RtpTransportTest, GetPacketTransports) { |
| 45 rtc::FakePacketTransport rtp("rtp"); |
| 46 rtc::FakePacketTransport rtcp("rtcp"); |
| 47 // With muxed RTCP. |
| 48 RtcpParameters rtcp_parameters; |
| 49 rtcp_parameters.mux = true; |
| 50 auto result = ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, |
| 51 nullptr, nullptr); |
| 52 ASSERT_TRUE(result.ok()); |
| 53 EXPECT_EQ(&rtp, result.value()->GetRtpPacketTransport()); |
| 54 EXPECT_EQ(nullptr, result.value()->GetRtcpPacketTransport()); |
| 55 result.MoveValue().reset(); |
| 56 // With non-muxed RTCP. |
| 57 rtcp_parameters.mux = false; |
| 58 result = |
| 59 ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr); |
| 60 ASSERT_TRUE(result.ok()); |
| 61 EXPECT_EQ(&rtp, result.value()->GetRtpPacketTransport()); |
| 62 EXPECT_EQ(&rtcp, result.value()->GetRtcpPacketTransport()); |
| 63 } |
| 64 |
| 65 // If an RtpTransport starts out un-muxed and then starts muxing, the RTCP |
| 66 // packet transport should be forgotten and GetRtcpPacketTransport should |
| 67 // return null. |
| 68 TEST_F(RtpTransportTest, EnablingRtcpMuxingUnsetsRtcpTransport) { |
| 69 rtc::FakePacketTransport rtp("rtp"); |
| 70 rtc::FakePacketTransport rtcp("rtcp"); |
| 71 |
| 72 // Create non-muxed. |
| 73 RtcpParameters rtcp_parameters; |
| 74 rtcp_parameters.mux = false; |
| 75 auto result = |
| 76 ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr); |
| 77 ASSERT_TRUE(result.ok()); |
| 78 auto rtp_transport = result.MoveValue(); |
| 79 |
| 80 // Enable muxing. |
| 81 rtcp_parameters.mux = true; |
| 82 EXPECT_TRUE(rtp_transport->SetRtcpParameters(rtcp_parameters).ok()); |
| 83 EXPECT_EQ(nullptr, rtp_transport->GetRtcpPacketTransport()); |
| 84 } |
| 85 |
| 86 TEST_F(RtpTransportTest, GetAndSetRtcpParameters) { |
| 87 rtc::FakePacketTransport rtp("rtp"); |
| 88 rtc::FakePacketTransport rtcp("rtcp"); |
| 89 // Start with non-muxed RTCP. |
| 90 RtcpParameters rtcp_parameters; |
| 91 rtcp_parameters.mux = false; |
| 92 rtcp_parameters.cname = "teST"; |
| 93 rtcp_parameters.reduced_size = false; |
| 94 auto result = |
| 95 ortc_factory_->CreateRtpTransport(rtcp_parameters, &rtp, &rtcp, nullptr); |
| 96 ASSERT_TRUE(result.ok()); |
| 97 auto transport = result.MoveValue(); |
| 98 EXPECT_EQ(rtcp_parameters, transport->GetRtcpParameters()); |
| 99 |
| 100 // Changing the CNAME is currently unsupported. |
| 101 rtcp_parameters.cname = "different"; |
| 102 EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION, |
| 103 transport->SetRtcpParameters(rtcp_parameters).type()); |
| 104 rtcp_parameters.cname = "teST"; |
| 105 |
| 106 // Enable RTCP muxing and reduced-size RTCP. |
| 107 rtcp_parameters.mux = true; |
| 108 rtcp_parameters.reduced_size = true; |
| 109 EXPECT_TRUE(transport->SetRtcpParameters(rtcp_parameters).ok()); |
| 110 EXPECT_EQ(rtcp_parameters, transport->GetRtcpParameters()); |
| 111 |
| 112 // Empty CNAME should result in the existing CNAME being used. |
| 113 rtcp_parameters.cname.clear(); |
| 114 EXPECT_TRUE(transport->SetRtcpParameters(rtcp_parameters).ok()); |
| 115 EXPECT_EQ("teST", transport->GetRtcpParameters().cname); |
| 116 |
| 117 // Disabling RTCP muxing after enabling shouldn't be allowed, since enabling |
| 118 // muxing should have made the RTP transport forget about the RTCP packet |
| 119 // transport initially passed into it. |
| 120 rtcp_parameters.mux = false; |
| 121 EXPECT_EQ(RTCErrorType::INVALID_STATE, |
| 122 transport->SetRtcpParameters(rtcp_parameters).type()); |
| 123 } |
| 124 |
| 125 // When Send or Receive is called on a sender or receiver, the RTCP parameters |
| 126 // from the RtpTransport underneath the sender should be applied to the created |
| 127 // media stream. The only relevant parameters (currently) are |cname| and |
| 128 // |reduced_size|. |
| 129 TEST_F(RtpTransportTest, SendAndReceiveApplyRtcpParametersToMediaEngine) { |
| 130 // First, create video transport with reduced-size RTCP. |
| 131 rtc::FakePacketTransport fake_packet_transport1("1"); |
| 132 RtcpParameters rtcp_parameters; |
| 133 rtcp_parameters.mux = true; |
| 134 rtcp_parameters.reduced_size = true; |
| 135 rtcp_parameters.cname = "foo"; |
| 136 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 137 rtcp_parameters, &fake_packet_transport1, nullptr, nullptr); |
| 138 auto video_transport = rtp_transport_result.MoveValue(); |
| 139 |
| 140 // Create video sender and call Send, expecting parameters to be applied. |
| 141 auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, |
| 142 video_transport.get()); |
| 143 auto video_sender = sender_result.MoveValue(); |
| 144 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 145 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 146 fake_media_engine_->GetVideoChannel(0); |
| 147 ASSERT_NE(nullptr, fake_video_channel); |
| 148 EXPECT_TRUE(fake_video_channel->send_rtcp_parameters().reduced_size); |
| 149 ASSERT_EQ(1u, fake_video_channel->send_streams().size()); |
| 150 const cricket::StreamParams& video_send_stream = |
| 151 fake_video_channel->send_streams()[0]; |
| 152 EXPECT_EQ("foo", video_send_stream.cname); |
| 153 |
| 154 // Create video receiver and call Receive, expecting parameters to be applied |
| 155 // (minus |cname|, since that's the sent cname, not received). |
| 156 auto receiver_result = ortc_factory_->CreateRtpReceiver( |
| 157 cricket::MEDIA_TYPE_VIDEO, video_transport.get()); |
| 158 auto video_receiver = receiver_result.MoveValue(); |
| 159 EXPECT_TRUE( |
| 160 video_receiver->Receive(MakeMinimalVp8ParametersWithSsrc(0xdeadbeef)) |
| 161 .ok()); |
| 162 EXPECT_TRUE(fake_video_channel->recv_rtcp_parameters().reduced_size); |
| 163 |
| 164 // Create audio transport with non-reduced size RTCP. |
| 165 rtc::FakePacketTransport fake_packet_transport2("2"); |
| 166 rtcp_parameters.reduced_size = false; |
| 167 rtcp_parameters.cname = "bar"; |
| 168 rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 169 rtcp_parameters, &fake_packet_transport2, nullptr, nullptr); |
| 170 auto audio_transport = rtp_transport_result.MoveValue(); |
| 171 |
| 172 // Create audio sender and call Send, expecting parameters to be applied. |
| 173 sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, |
| 174 audio_transport.get()); |
| 175 auto audio_sender = sender_result.MoveValue(); |
| 176 EXPECT_TRUE(audio_sender->Send(MakeMinimalIsacParameters()).ok()); |
| 177 |
| 178 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 179 fake_media_engine_->GetVoiceChannel(0); |
| 180 ASSERT_NE(nullptr, fake_voice_channel); |
| 181 EXPECT_FALSE(fake_voice_channel->send_rtcp_parameters().reduced_size); |
| 182 ASSERT_EQ(1u, fake_voice_channel->send_streams().size()); |
| 183 const cricket::StreamParams& audio_send_stream = |
| 184 fake_voice_channel->send_streams()[0]; |
| 185 EXPECT_EQ("bar", audio_send_stream.cname); |
| 186 |
| 187 // Create audio receiver and call Receive, expecting parameters to be applied |
| 188 // (minus |cname|, since that's the sent cname, not received). |
| 189 receiver_result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO, |
| 190 audio_transport.get()); |
| 191 auto audio_receiver = receiver_result.MoveValue(); |
| 192 EXPECT_TRUE( |
| 193 audio_receiver->Receive(MakeMinimalOpusParametersWithSsrc(0xbaadf00d)) |
| 194 .ok()); |
| 195 EXPECT_FALSE(fake_voice_channel->recv_rtcp_parameters().reduced_size); |
| 196 } |
| 197 |
| 198 // When SetRtcpParameters is called, the modified parameters should be applied |
| 199 // to the media engine. |
| 200 // TODO(deadbeef): Once the implementation supports changing the CNAME, |
| 201 // test that here. |
| 202 TEST_F(RtpTransportTest, SetRtcpParametersAppliesParametersToMediaEngine) { |
| 203 rtc::FakePacketTransport fake_packet_transport("fake"); |
| 204 RtcpParameters rtcp_parameters; |
| 205 rtcp_parameters.mux = true; |
| 206 rtcp_parameters.reduced_size = false; |
| 207 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 208 rtcp_parameters, &fake_packet_transport, nullptr, nullptr); |
| 209 auto rtp_transport = rtp_transport_result.MoveValue(); |
| 210 |
| 211 // Create video sender and call Send, applying an initial set of parameters. |
| 212 auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, |
| 213 rtp_transport.get()); |
| 214 auto sender = sender_result.MoveValue(); |
| 215 EXPECT_TRUE(sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 216 |
| 217 // Modify parameters and expect them to be changed at the media engine level. |
| 218 rtcp_parameters.reduced_size = true; |
| 219 EXPECT_TRUE(rtp_transport->SetRtcpParameters(rtcp_parameters).ok()); |
| 220 |
| 221 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 222 fake_media_engine_->GetVideoChannel(0); |
| 223 ASSERT_NE(nullptr, fake_video_channel); |
| 224 EXPECT_TRUE(fake_video_channel->send_rtcp_parameters().reduced_size); |
| 225 } |
| 226 |
| 227 } // namespace webrtc |
OLD | NEW |