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 #include <utility> // For std::pair, std::move. |
| 13 |
| 14 #include "webrtc/api/ortc/ortcfactoryinterface.h" |
| 15 #include "webrtc/base/criticalsection.h" |
| 16 #include "webrtc/base/fakenetwork.h" |
| 17 #include "webrtc/base/gunit.h" |
| 18 #include "webrtc/base/physicalsocketserver.h" |
| 19 #include "webrtc/base/virtualsocketserver.h" |
| 20 #include "webrtc/ortc/testrtpparameters.h" |
| 21 #include "webrtc/p2p/base/udptransport.h" |
| 22 #include "webrtc/pc/test/fakeaudiocapturemodule.h" |
| 23 #include "webrtc/pc/test/fakeperiodicvideocapturer.h" |
| 24 #include "webrtc/pc/test/fakevideotrackrenderer.h" |
| 25 |
| 26 namespace { |
| 27 |
| 28 const int kDefaultTimeout = 10000; // 10 seconds. |
| 29 // Default number of audio/video frames to wait for before considering a test a |
| 30 // success. |
| 31 const int kDefaultNumFrames = 3; |
| 32 const rtc::IPAddress kIPv4LocalHostAddress = |
| 33 rtc::IPAddress(0x7F000001); // 127.0.0.1 |
| 34 |
| 35 } // namespace |
| 36 |
| 37 namespace webrtc { |
| 38 |
| 39 // Used to test that things work end-to-end when using the default |
| 40 // implementations of threads/etc. provided by OrtcFactory, with the exception |
| 41 // of using a virtual network. |
| 42 // |
| 43 // By default, the virtual network manager doesn't enumerate any networks, but |
| 44 // sockets can still be created in this state. |
| 45 class OrtcFactoryIntegrationTest : public testing::Test { |
| 46 public: |
| 47 OrtcFactoryIntegrationTest() |
| 48 : virtual_socket_server_(&physical_socket_server_), |
| 49 network_thread_(&virtual_socket_server_), |
| 50 fake_audio_capture_module1_(FakeAudioCaptureModule::Create()), |
| 51 fake_audio_capture_module2_(FakeAudioCaptureModule::Create()) { |
| 52 // Sockets are bound to the ANY address, so this is needed to tell the |
| 53 // virtual network which address to use in this case. |
| 54 virtual_socket_server_.SetDefaultRoute(kIPv4LocalHostAddress); |
| 55 network_thread_.Start(); |
| 56 // Need to create after network thread is started. |
| 57 ortc_factory1_ = OrtcFactoryInterface::Create( |
| 58 &network_thread_, nullptr, &fake_network_manager_, |
| 59 nullptr, fake_audio_capture_module1_) |
| 60 .MoveValue(); |
| 61 ortc_factory2_ = OrtcFactoryInterface::Create( |
| 62 &network_thread_, nullptr, &fake_network_manager_, |
| 63 nullptr, fake_audio_capture_module2_) |
| 64 .MoveValue(); |
| 65 } |
| 66 |
| 67 protected: |
| 68 typedef std::pair<std::unique_ptr<UdpTransportInterface>, |
| 69 std::unique_ptr<UdpTransportInterface>> |
| 70 UdpTransportPair; |
| 71 typedef std::pair<std::unique_ptr<RtpTransportInterface>, |
| 72 std::unique_ptr<RtpTransportInterface>> |
| 73 RtpTransportPair; |
| 74 typedef std::pair<std::unique_ptr<RtpTransportControllerInterface>, |
| 75 std::unique_ptr<RtpTransportControllerInterface>> |
| 76 RtpTransportControllerPair; |
| 77 |
| 78 // Helper function that creates one UDP transport each for |ortc_factory1_| |
| 79 // and |ortc_factory2_|, and connects them. |
| 80 UdpTransportPair CreateAndConnectUdpTransportPair() { |
| 81 auto transport1 = ortc_factory1_->CreateUdpTransport(AF_INET).MoveValue(); |
| 82 auto transport2 = ortc_factory2_->CreateUdpTransport(AF_INET).MoveValue(); |
| 83 transport1->SetRemoteAddress( |
| 84 rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET), |
| 85 transport2->GetLocalAddress().port())); |
| 86 transport2->SetRemoteAddress( |
| 87 rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET), |
| 88 transport1->GetLocalAddress().port())); |
| 89 return {std::move(transport1), std::move(transport2)}; |
| 90 } |
| 91 |
| 92 // Creates one transport controller each for |ortc_factory1_| and |
| 93 // |ortc_factory2_|. |
| 94 RtpTransportControllerPair CreateRtpTransportControllerPair() { |
| 95 return {ortc_factory1_->CreateRtpTransportController().MoveValue(), |
| 96 ortc_factory2_->CreateRtpTransportController().MoveValue()}; |
| 97 } |
| 98 |
| 99 // Helper function that creates a pair of RtpTransports between |
| 100 // |ortc_factory1_| and |ortc_factory2_|. Expected to be called with the |
| 101 // result of CreateAndConnectUdpTransportPair. |rtcp_udp_transports| can be |
| 102 // empty if RTCP muxing is used. |transport_controllers| can be empty if |
| 103 // these transports are being created using a default transport controller. |
| 104 RtpTransportPair CreateRtpTransportPair( |
| 105 const RtcpParameters& rtcp_parameters, |
| 106 const UdpTransportPair& rtp_udp_transports, |
| 107 const UdpTransportPair& rtcp_udp_transports, |
| 108 const RtpTransportControllerPair& transport_controllers) { |
| 109 auto transport_result1 = ortc_factory1_->CreateRtpTransport( |
| 110 rtcp_parameters, rtp_udp_transports.first.get(), |
| 111 rtcp_udp_transports.first.get(), transport_controllers.first.get()); |
| 112 auto transport_result2 = ortc_factory2_->CreateRtpTransport( |
| 113 rtcp_parameters, rtp_udp_transports.second.get(), |
| 114 rtcp_udp_transports.second.get(), transport_controllers.second.get()); |
| 115 return {transport_result1.MoveValue(), transport_result2.MoveValue()}; |
| 116 } |
| 117 |
| 118 // For convenience when |rtcp_udp_transports| and |transport_controllers| |
| 119 // aren't needed. |
| 120 RtpTransportPair CreateRtpTransportPair( |
| 121 const RtcpParameters& rtcp_parameters, |
| 122 const UdpTransportPair& rtp_udp_transports) { |
| 123 return CreateRtpTransportPair(rtcp_parameters, rtp_udp_transports, |
| 124 UdpTransportPair(), |
| 125 RtpTransportControllerPair()); |
| 126 } |
| 127 |
| 128 // Ends up using fake audio capture module, which was passed into OrtcFactory |
| 129 // on creation. |
| 130 rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack( |
| 131 const std::string& id, |
| 132 OrtcFactoryInterface* ortc_factory) { |
| 133 // Disable echo cancellation to make test more efficient. |
| 134 cricket::AudioOptions options; |
| 135 options.echo_cancellation.emplace(true); |
| 136 rtc::scoped_refptr<webrtc::AudioSourceInterface> source = |
| 137 ortc_factory->CreateAudioSource(options); |
| 138 return ortc_factory->CreateAudioTrack(id, source); |
| 139 } |
| 140 |
| 141 // Stores created capturer in |fake_video_capturers_|. |
| 142 rtc::scoped_refptr<webrtc::VideoTrackInterface> |
| 143 CreateLocalVideoTrackAndFakeCapturer(const std::string& id, |
| 144 OrtcFactoryInterface* ortc_factory) { |
| 145 cricket::FakeVideoCapturer* fake_capturer = |
| 146 new webrtc::FakePeriodicVideoCapturer(); |
| 147 fake_video_capturers_.push_back(fake_capturer); |
| 148 rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> source = |
| 149 ortc_factory->CreateVideoSource( |
| 150 std::unique_ptr<cricket::VideoCapturer>(fake_capturer)); |
| 151 return rtc::scoped_refptr<webrtc::VideoTrackInterface>( |
| 152 ortc_factory->CreateVideoTrack(id, source)); |
| 153 } |
| 154 |
| 155 rtc::PhysicalSocketServer physical_socket_server_; |
| 156 rtc::VirtualSocketServer virtual_socket_server_; |
| 157 rtc::Thread network_thread_; |
| 158 rtc::FakeNetworkManager fake_network_manager_; |
| 159 rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module1_; |
| 160 rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module2_; |
| 161 std::unique_ptr<OrtcFactoryInterface> ortc_factory1_; |
| 162 std::unique_ptr<OrtcFactoryInterface> ortc_factory2_; |
| 163 // Actually owned by video tracks. |
| 164 std::vector<cricket::FakeVideoCapturer*> fake_video_capturers_; |
| 165 }; |
| 166 |
| 167 // Very basic end-to-end test with a single pair of audio RTP sender and |
| 168 // receiver. |
| 169 // |
| 170 // Uses muxed RTCP, and minimal parameters with a hard-coded config that's |
| 171 // known to work. |
| 172 TEST_F(OrtcFactoryIntegrationTest, BasicOneWayAudioRtpSenderAndReceiver) { |
| 173 auto udp_transports = CreateAndConnectUdpTransportPair(); |
| 174 auto rtp_transports = |
| 175 CreateRtpTransportPair(MakeRtcpMuxParameters(), udp_transports); |
| 176 |
| 177 auto sender_result = ortc_factory1_->CreateRtpSender( |
| 178 cricket::MEDIA_TYPE_AUDIO, rtp_transports.first.get()); |
| 179 auto receiver_result = ortc_factory2_->CreateRtpReceiver( |
| 180 cricket::MEDIA_TYPE_AUDIO, rtp_transports.second.get()); |
| 181 ASSERT_TRUE(sender_result.ok()); |
| 182 ASSERT_TRUE(receiver_result.ok()); |
| 183 auto sender = sender_result.MoveValue(); |
| 184 auto receiver = receiver_result.MoveValue(); |
| 185 |
| 186 RTCError error = |
| 187 sender->SetTrack(CreateLocalAudioTrack("audio", ortc_factory1_.get())); |
| 188 EXPECT_TRUE(error.ok()); |
| 189 |
| 190 RtpParameters opus_parameters = MakeMinimalOpusParameters(); |
| 191 EXPECT_TRUE(receiver->Receive(opus_parameters).ok()); |
| 192 EXPECT_TRUE(sender->Send(opus_parameters).ok()); |
| 193 // Sender and receiver are connected and configured; audio frames should be |
| 194 // able to flow at this point. |
| 195 EXPECT_TRUE_WAIT( |
| 196 fake_audio_capture_module2_->frames_received() > kDefaultNumFrames, |
| 197 kDefaultTimeout); |
| 198 } |
| 199 |
| 200 // Very basic end-to-end test with a single pair of video RTP sender and |
| 201 // receiver. |
| 202 // |
| 203 // Uses muxed RTCP, and minimal parameters with a hard-coded config that's |
| 204 // known to work. |
| 205 TEST_F(OrtcFactoryIntegrationTest, BasicOneWayVideoRtpSenderAndReceiver) { |
| 206 auto udp_transports = CreateAndConnectUdpTransportPair(); |
| 207 auto rtp_transports = |
| 208 CreateRtpTransportPair(MakeRtcpMuxParameters(), udp_transports); |
| 209 |
| 210 auto sender_result = ortc_factory1_->CreateRtpSender( |
| 211 cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get()); |
| 212 auto receiver_result = ortc_factory2_->CreateRtpReceiver( |
| 213 cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get()); |
| 214 ASSERT_TRUE(sender_result.ok()); |
| 215 ASSERT_TRUE(receiver_result.ok()); |
| 216 auto sender = sender_result.MoveValue(); |
| 217 auto receiver = receiver_result.MoveValue(); |
| 218 |
| 219 RTCError error = sender->SetTrack( |
| 220 CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory1_.get())); |
| 221 EXPECT_TRUE(error.ok()); |
| 222 |
| 223 RtpParameters vp8_parameters = MakeMinimalVp8Parameters(); |
| 224 EXPECT_TRUE(receiver->Receive(vp8_parameters).ok()); |
| 225 EXPECT_TRUE(sender->Send(vp8_parameters).ok()); |
| 226 FakeVideoTrackRenderer fake_renderer( |
| 227 static_cast<VideoTrackInterface*>(receiver->GetTrack().get())); |
| 228 // Sender and receiver are connected and configured; video frames should be |
| 229 // able to flow at this point. |
| 230 EXPECT_TRUE_WAIT(fake_renderer.num_rendered_frames() > kDefaultNumFrames, |
| 231 kDefaultTimeout); |
| 232 } |
| 233 |
| 234 // Test that if the track is changed while sending, the sender seamlessly |
| 235 // transitions to sending it and frames are received end-to-end. |
| 236 // |
| 237 // Only doing this for video, since given that audio is sourced from a single |
| 238 // fake audio capture module, the audio track is just a dummy object. |
| 239 // TODO(deadbeef): Change this when possible. |
| 240 TEST_F(OrtcFactoryIntegrationTest, SetTrackWhileSending) { |
| 241 auto udp_transports = CreateAndConnectUdpTransportPair(); |
| 242 auto rtp_transports = |
| 243 CreateRtpTransportPair(MakeRtcpMuxParameters(), udp_transports); |
| 244 |
| 245 auto sender_result = ortc_factory1_->CreateRtpSender( |
| 246 cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get()); |
| 247 auto receiver_result = ortc_factory2_->CreateRtpReceiver( |
| 248 cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get()); |
| 249 ASSERT_TRUE(sender_result.ok()); |
| 250 ASSERT_TRUE(receiver_result.ok()); |
| 251 auto sender = sender_result.MoveValue(); |
| 252 auto receiver = receiver_result.MoveValue(); |
| 253 |
| 254 RTCError error = sender->SetTrack( |
| 255 CreateLocalVideoTrackAndFakeCapturer("video_1", ortc_factory1_.get())); |
| 256 EXPECT_TRUE(error.ok()); |
| 257 RtpParameters vp8_parameters = MakeMinimalVp8Parameters(); |
| 258 EXPECT_TRUE(receiver->Receive(vp8_parameters).ok()); |
| 259 EXPECT_TRUE(sender->Send(vp8_parameters).ok()); |
| 260 FakeVideoTrackRenderer fake_renderer( |
| 261 static_cast<VideoTrackInterface*>(receiver->GetTrack().get())); |
| 262 // Expect for some initial number of frames to be received. |
| 263 EXPECT_TRUE_WAIT(fake_renderer.num_rendered_frames() > kDefaultNumFrames, |
| 264 kDefaultTimeout); |
| 265 // Stop the old capturer, set a new track, and verify new frames are received |
| 266 // from the new track. Stopping the old capturer ensures that we aren't |
| 267 // actually still getting frames from it. |
| 268 fake_video_capturers_[0]->Stop(); |
| 269 int prev_num_frames = fake_renderer.num_rendered_frames(); |
| 270 error = sender->SetTrack( |
| 271 CreateLocalVideoTrackAndFakeCapturer("video_2", ortc_factory1_.get())); |
| 272 EXPECT_TRUE(error.ok()); |
| 273 EXPECT_TRUE_WAIT( |
| 274 fake_renderer.num_rendered_frames() > kDefaultNumFrames + prev_num_frames, |
| 275 kDefaultTimeout); |
| 276 } |
| 277 |
| 278 // End-to-end test with two pairs of RTP senders and receivers, for audio and |
| 279 // video. |
| 280 // |
| 281 // Uses muxed RTCP, and minimal parameters with hard-coded configs that are |
| 282 // known to work. |
| 283 TEST_F(OrtcFactoryIntegrationTest, |
| 284 BasicTwoWayAudioVideoRtpSendersAndReceivers) { |
| 285 auto udp_transports = CreateAndConnectUdpTransportPair(); |
| 286 auto rtp_transports = |
| 287 CreateRtpTransportPair(MakeRtcpMuxParameters(), udp_transports); |
| 288 |
| 289 // Create all the senders and receivers (four per endpoint). |
| 290 auto audio_sender_result1 = ortc_factory1_->CreateRtpSender( |
| 291 cricket::MEDIA_TYPE_AUDIO, rtp_transports.first.get()); |
| 292 auto video_sender_result1 = ortc_factory1_->CreateRtpSender( |
| 293 cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get()); |
| 294 auto audio_receiver_result1 = ortc_factory1_->CreateRtpReceiver( |
| 295 cricket::MEDIA_TYPE_AUDIO, rtp_transports.first.get()); |
| 296 auto video_receiver_result1 = ortc_factory1_->CreateRtpReceiver( |
| 297 cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get()); |
| 298 ASSERT_TRUE(audio_sender_result1.ok()); |
| 299 ASSERT_TRUE(video_sender_result1.ok()); |
| 300 ASSERT_TRUE(audio_receiver_result1.ok()); |
| 301 ASSERT_TRUE(video_receiver_result1.ok()); |
| 302 auto audio_sender1 = audio_sender_result1.MoveValue(); |
| 303 auto video_sender1 = video_sender_result1.MoveValue(); |
| 304 auto audio_receiver1 = audio_receiver_result1.MoveValue(); |
| 305 auto video_receiver1 = video_receiver_result1.MoveValue(); |
| 306 |
| 307 auto audio_sender_result2 = ortc_factory2_->CreateRtpSender( |
| 308 cricket::MEDIA_TYPE_AUDIO, rtp_transports.second.get()); |
| 309 auto video_sender_result2 = ortc_factory2_->CreateRtpSender( |
| 310 cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get()); |
| 311 auto audio_receiver_result2 = ortc_factory2_->CreateRtpReceiver( |
| 312 cricket::MEDIA_TYPE_AUDIO, rtp_transports.second.get()); |
| 313 auto video_receiver_result2 = ortc_factory2_->CreateRtpReceiver( |
| 314 cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get()); |
| 315 ASSERT_TRUE(audio_sender_result2.ok()); |
| 316 ASSERT_TRUE(video_sender_result2.ok()); |
| 317 ASSERT_TRUE(audio_receiver_result2.ok()); |
| 318 ASSERT_TRUE(video_receiver_result2.ok()); |
| 319 auto audio_sender2 = audio_sender_result2.MoveValue(); |
| 320 auto video_sender2 = video_sender_result2.MoveValue(); |
| 321 auto audio_receiver2 = audio_receiver_result2.MoveValue(); |
| 322 auto video_receiver2 = video_receiver_result2.MoveValue(); |
| 323 |
| 324 // Add fake tracks. |
| 325 RTCError error = audio_sender1->SetTrack( |
| 326 CreateLocalAudioTrack("audio", ortc_factory1_.get())); |
| 327 EXPECT_TRUE(error.ok()); |
| 328 error = video_sender1->SetTrack( |
| 329 CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory1_.get())); |
| 330 EXPECT_TRUE(error.ok()); |
| 331 error = audio_sender2->SetTrack( |
| 332 CreateLocalAudioTrack("audio", ortc_factory2_.get())); |
| 333 EXPECT_TRUE(error.ok()); |
| 334 error = video_sender2->SetTrack( |
| 335 CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory2_.get())); |
| 336 EXPECT_TRUE(error.ok()); |
| 337 |
| 338 // "sent_X_parameters1" are the parameters that endpoint 1 sends with and |
| 339 // endpoint 2 receives with. |
| 340 RtpParameters sent_opus_parameters1 = |
| 341 MakeMinimalOpusParametersWithSsrc(0xdeadbeef); |
| 342 RtpParameters sent_vp8_parameters1 = |
| 343 MakeMinimalVp8ParametersWithSsrc(0xbaadfeed); |
| 344 RtpParameters sent_opus_parameters2 = |
| 345 MakeMinimalOpusParametersWithSsrc(0x13333337); |
| 346 RtpParameters sent_vp8_parameters2 = |
| 347 MakeMinimalVp8ParametersWithSsrc(0x12345678); |
| 348 |
| 349 // Configure the senders' and receivers' parameters. |
| 350 EXPECT_TRUE(audio_receiver1->Receive(sent_opus_parameters2).ok()); |
| 351 EXPECT_TRUE(video_receiver1->Receive(sent_vp8_parameters2).ok()); |
| 352 EXPECT_TRUE(audio_receiver2->Receive(sent_opus_parameters1).ok()); |
| 353 EXPECT_TRUE(video_receiver2->Receive(sent_vp8_parameters1).ok()); |
| 354 EXPECT_TRUE(audio_sender1->Send(sent_opus_parameters1).ok()); |
| 355 EXPECT_TRUE(video_sender1->Send(sent_vp8_parameters1).ok()); |
| 356 EXPECT_TRUE(audio_sender2->Send(sent_opus_parameters2).ok()); |
| 357 EXPECT_TRUE(video_sender2->Send(sent_vp8_parameters2).ok()); |
| 358 |
| 359 FakeVideoTrackRenderer fake_video_renderer1( |
| 360 static_cast<VideoTrackInterface*>(video_receiver1->GetTrack().get())); |
| 361 FakeVideoTrackRenderer fake_video_renderer2( |
| 362 static_cast<VideoTrackInterface*>(video_receiver2->GetTrack().get())); |
| 363 |
| 364 // Senders and receivers are connected and configured; audio and video frames |
| 365 // should be able to flow at this point. |
| 366 EXPECT_TRUE_WAIT( |
| 367 fake_audio_capture_module1_->frames_received() > kDefaultNumFrames && |
| 368 fake_video_renderer1.num_rendered_frames() > kDefaultNumFrames && |
| 369 fake_audio_capture_module2_->frames_received() > kDefaultNumFrames && |
| 370 fake_video_renderer2.num_rendered_frames() > kDefaultNumFrames, |
| 371 kDefaultTimeout); |
| 372 } |
| 373 |
| 374 // End-to-end test with two pairs of RTP senders and receivers, for audio and |
| 375 // video. Unlike the test above, this attempts to make the parameters as |
| 376 // complex as possible. |
| 377 // |
| 378 // Uses non-muxed RTCP, with separate audio/video transports, and a full set of |
| 379 // parameters, as would normally be used in a PeerConnection. |
| 380 // |
| 381 // TODO(deadbeef): Update this test as more audio/video features become |
| 382 // supported. |
| 383 TEST_F(OrtcFactoryIntegrationTest, FullTwoWayAudioVideoRtpSendersAndReceivers) { |
| 384 // We want four pairs of UDP transports for this test, for audio/video and |
| 385 // RTP/RTCP. |
| 386 auto audio_rtp_udp_transports = CreateAndConnectUdpTransportPair(); |
| 387 auto audio_rtcp_udp_transports = CreateAndConnectUdpTransportPair(); |
| 388 auto video_rtp_udp_transports = CreateAndConnectUdpTransportPair(); |
| 389 auto video_rtcp_udp_transports = CreateAndConnectUdpTransportPair(); |
| 390 |
| 391 // Since we have multiple RTP transports on each side, we need an RTP |
| 392 // transport controller. |
| 393 auto transport_controllers = CreateRtpTransportControllerPair(); |
| 394 |
| 395 RtcpParameters audio_rtcp_parameters; |
| 396 audio_rtcp_parameters.mux = false; |
| 397 auto audio_rtp_transports = |
| 398 CreateRtpTransportPair(audio_rtcp_parameters, audio_rtp_udp_transports, |
| 399 audio_rtcp_udp_transports, transport_controllers); |
| 400 |
| 401 RtcpParameters video_rtcp_parameters; |
| 402 video_rtcp_parameters.mux = false; |
| 403 video_rtcp_parameters.reduced_size = true; |
| 404 auto video_rtp_transports = |
| 405 CreateRtpTransportPair(video_rtcp_parameters, video_rtp_udp_transports, |
| 406 video_rtcp_udp_transports, transport_controllers); |
| 407 |
| 408 // Create all the senders and receivers (four per endpoint). |
| 409 auto audio_sender_result1 = ortc_factory1_->CreateRtpSender( |
| 410 cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.first.get()); |
| 411 auto video_sender_result1 = ortc_factory1_->CreateRtpSender( |
| 412 cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.first.get()); |
| 413 auto audio_receiver_result1 = ortc_factory1_->CreateRtpReceiver( |
| 414 cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.first.get()); |
| 415 auto video_receiver_result1 = ortc_factory1_->CreateRtpReceiver( |
| 416 cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.first.get()); |
| 417 ASSERT_TRUE(audio_sender_result1.ok()); |
| 418 ASSERT_TRUE(video_sender_result1.ok()); |
| 419 ASSERT_TRUE(audio_receiver_result1.ok()); |
| 420 ASSERT_TRUE(video_receiver_result1.ok()); |
| 421 auto audio_sender1 = audio_sender_result1.MoveValue(); |
| 422 auto video_sender1 = video_sender_result1.MoveValue(); |
| 423 auto audio_receiver1 = audio_receiver_result1.MoveValue(); |
| 424 auto video_receiver1 = video_receiver_result1.MoveValue(); |
| 425 |
| 426 auto audio_sender_result2 = ortc_factory2_->CreateRtpSender( |
| 427 cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.second.get()); |
| 428 auto video_sender_result2 = ortc_factory2_->CreateRtpSender( |
| 429 cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.second.get()); |
| 430 auto audio_receiver_result2 = ortc_factory2_->CreateRtpReceiver( |
| 431 cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.second.get()); |
| 432 auto video_receiver_result2 = ortc_factory2_->CreateRtpReceiver( |
| 433 cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.second.get()); |
| 434 ASSERT_TRUE(audio_sender_result2.ok()); |
| 435 ASSERT_TRUE(video_sender_result2.ok()); |
| 436 ASSERT_TRUE(audio_receiver_result2.ok()); |
| 437 ASSERT_TRUE(video_receiver_result2.ok()); |
| 438 auto audio_sender2 = audio_sender_result2.MoveValue(); |
| 439 auto video_sender2 = video_sender_result2.MoveValue(); |
| 440 auto audio_receiver2 = audio_receiver_result2.MoveValue(); |
| 441 auto video_receiver2 = video_receiver_result2.MoveValue(); |
| 442 |
| 443 RTCError error = audio_sender1->SetTrack( |
| 444 CreateLocalAudioTrack("audio", ortc_factory1_.get())); |
| 445 EXPECT_TRUE(error.ok()); |
| 446 error = video_sender1->SetTrack( |
| 447 CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory1_.get())); |
| 448 EXPECT_TRUE(error.ok()); |
| 449 error = audio_sender2->SetTrack( |
| 450 CreateLocalAudioTrack("audio", ortc_factory2_.get())); |
| 451 EXPECT_TRUE(error.ok()); |
| 452 error = video_sender2->SetTrack( |
| 453 CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory2_.get())); |
| 454 EXPECT_TRUE(error.ok()); |
| 455 |
| 456 // Use different codecs in different directions for extra challenge. |
| 457 RtpParameters opus_send_parameters = MakeFullOpusParameters(); |
| 458 RtpParameters isac_send_parameters = MakeFullIsacParameters(); |
| 459 RtpParameters vp8_send_parameters = MakeFullVp8Parameters(); |
| 460 RtpParameters vp9_send_parameters = MakeFullVp9Parameters(); |
| 461 |
| 462 // Remove "payload_type" from receive parameters. Receiver will need to |
| 463 // discern the payload type from packets received. |
| 464 RtpParameters opus_receive_parameters = opus_send_parameters; |
| 465 RtpParameters isac_receive_parameters = isac_send_parameters; |
| 466 RtpParameters vp8_receive_parameters = vp8_send_parameters; |
| 467 RtpParameters vp9_receive_parameters = vp9_send_parameters; |
| 468 opus_receive_parameters.encodings[0].codec_payload_type.reset(); |
| 469 isac_receive_parameters.encodings[0].codec_payload_type.reset(); |
| 470 vp8_receive_parameters.encodings[0].codec_payload_type.reset(); |
| 471 vp9_receive_parameters.encodings[0].codec_payload_type.reset(); |
| 472 |
| 473 // Configure the senders' and receivers' parameters. |
| 474 // |
| 475 // Note: Intentionally, the top codec in the receive parameters does not |
| 476 // match the codec sent by the other side. If "Receive" is called with a list |
| 477 // of codecs, the receiver should be prepared to receive any of them, not |
| 478 // just the one on top. |
| 479 EXPECT_TRUE(audio_receiver1->Receive(opus_receive_parameters).ok()); |
| 480 EXPECT_TRUE(video_receiver1->Receive(vp8_receive_parameters).ok()); |
| 481 EXPECT_TRUE(audio_receiver2->Receive(isac_receive_parameters).ok()); |
| 482 EXPECT_TRUE(video_receiver2->Receive(vp9_receive_parameters).ok()); |
| 483 EXPECT_TRUE(audio_sender1->Send(opus_send_parameters).ok()); |
| 484 EXPECT_TRUE(video_sender1->Send(vp8_send_parameters).ok()); |
| 485 EXPECT_TRUE(audio_sender2->Send(isac_send_parameters).ok()); |
| 486 EXPECT_TRUE(video_sender2->Send(vp9_send_parameters).ok()); |
| 487 |
| 488 FakeVideoTrackRenderer fake_video_renderer1( |
| 489 static_cast<VideoTrackInterface*>(video_receiver1->GetTrack().get())); |
| 490 FakeVideoTrackRenderer fake_video_renderer2( |
| 491 static_cast<VideoTrackInterface*>(video_receiver2->GetTrack().get())); |
| 492 |
| 493 // Senders and receivers are connected and configured; audio and video frames |
| 494 // should be able to flow at this point. |
| 495 EXPECT_TRUE_WAIT( |
| 496 fake_audio_capture_module1_->frames_received() > kDefaultNumFrames && |
| 497 fake_video_renderer1.num_rendered_frames() > kDefaultNumFrames && |
| 498 fake_audio_capture_module2_->frames_received() > kDefaultNumFrames && |
| 499 fake_video_renderer2.num_rendered_frames() > kDefaultNumFrames, |
| 500 kDefaultTimeout); |
| 501 } |
| 502 |
| 503 // TODO(deadbeef): End-to-end test for multiple senders/receivers of the same |
| 504 // media type, once that's supported. Currently, it is not because the |
| 505 // BaseChannel model relies on there being a single VoiceChannel and |
| 506 // VideoChannel, and these only support a single set of codecs/etc. per |
| 507 // send/receive direction. |
| 508 |
| 509 // TODO(deadbeef): End-to-end test for simulcast, once that's supported by this |
| 510 // API. |
| 511 |
| 512 } // namespace webrtc |
OLD | NEW |