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/p2p/base/fakepackettransport.h" |
| 16 #include "webrtc/ortc/ortcfactory.h" |
| 17 #include "webrtc/ortc/testrtpparameters.h" |
| 18 #include "webrtc/pc/test/fakevideotracksource.h" |
| 19 |
| 20 namespace webrtc { |
| 21 |
| 22 // This test uses an individual RtpSender using only the public interface, and |
| 23 // verifies that its behaves as designed at an API level. Also tests that |
| 24 // parameters are applied to the audio/video engines as expected. Network and |
| 25 // media interfaces are faked to isolate what's being tested. |
| 26 // |
| 27 // This test shouldn't result any any actual media being sent. That sort of |
| 28 // test should go in ortcfactory_integrationtest.cc. |
| 29 class OrtcRtpSenderTest : public testing::Test { |
| 30 public: |
| 31 OrtcRtpSenderTest() : fake_packet_transport_("fake") { |
| 32 // Need to set the fake packet transport to writable, in order to test that |
| 33 // the "send" flag is applied to the media engine based on the encoding |
| 34 // |active| flag. |
| 35 fake_packet_transport_.SetWritable(true); |
| 36 fake_media_engine_ = new cricket::FakeMediaEngine(); |
| 37 // Note: This doesn't need to use fake network classes, since we already |
| 38 // use FakePacketTransport. |
| 39 auto ortc_factory_result = OrtcFactory::Create( |
| 40 nullptr, nullptr, nullptr, nullptr, nullptr, |
| 41 std::unique_ptr<cricket::MediaEngineInterface>(fake_media_engine_)); |
| 42 ortc_factory_ = ortc_factory_result.MoveValue(); |
| 43 RtcpParameters rtcp_parameters; |
| 44 rtcp_parameters.mux = true; |
| 45 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 46 rtcp_parameters, &fake_packet_transport_, nullptr, nullptr); |
| 47 rtp_transport_ = rtp_transport_result.MoveValue(); |
| 48 } |
| 49 |
| 50 protected: |
| 51 rtc::scoped_refptr<AudioTrackInterface> CreateAudioTrack( |
| 52 const std::string& id) { |
| 53 return ortc_factory_->CreateAudioTrack(id, nullptr); |
| 54 } |
| 55 |
| 56 rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack( |
| 57 const std::string& id) { |
| 58 return rtc::scoped_refptr<webrtc::VideoTrackInterface>( |
| 59 ortc_factory_->CreateVideoTrack(id, FakeVideoTrackSource::Create())); |
| 60 } |
| 61 |
| 62 // Owned by |ortc_factory_|. |
| 63 cricket::FakeMediaEngine* fake_media_engine_; |
| 64 rtc::FakePacketTransport fake_packet_transport_; |
| 65 std::unique_ptr<OrtcFactoryInterface> ortc_factory_; |
| 66 std::unique_ptr<RtpTransportInterface> rtp_transport_; |
| 67 }; |
| 68 |
| 69 TEST_F(OrtcRtpSenderTest, GetAndSetTrack) { |
| 70 // Test GetTrack with a sender constructed with a track. |
| 71 auto audio_track = CreateAudioTrack("audio"); |
| 72 auto audio_sender_result = |
| 73 ortc_factory_->CreateRtpSender(audio_track, rtp_transport_.get()); |
| 74 auto audio_sender = audio_sender_result.MoveValue(); |
| 75 EXPECT_EQ(audio_track, audio_sender->GetTrack()); |
| 76 |
| 77 // Test GetTrack after SetTrack. |
| 78 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 79 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 80 auto video_sender = video_sender_result.MoveValue(); |
| 81 auto video_track = CreateVideoTrack("video1"); |
| 82 EXPECT_TRUE(video_sender->SetTrack(video_track).ok()); |
| 83 EXPECT_EQ(video_track, video_sender->GetTrack()); |
| 84 video_track = CreateVideoTrack("video2"); |
| 85 EXPECT_TRUE(video_sender->SetTrack(video_track).ok()); |
| 86 EXPECT_EQ(video_track, video_sender->GetTrack()); |
| 87 } |
| 88 |
| 89 // Test that track can be set when previously unset, even after Send has been |
| 90 // called. |
| 91 TEST_F(OrtcRtpSenderTest, SetTrackWhileSending) { |
| 92 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 93 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 94 auto audio_sender = audio_sender_result.MoveValue(); |
| 95 EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok()); |
| 96 EXPECT_TRUE(audio_sender->SetTrack(CreateAudioTrack("audio")).ok()); |
| 97 |
| 98 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 99 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 100 auto video_sender = video_sender_result.MoveValue(); |
| 101 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 102 EXPECT_TRUE(video_sender->SetTrack(CreateVideoTrack("video")).ok()); |
| 103 } |
| 104 |
| 105 // Test that track can be changed mid-sending. Differs from the above test in |
| 106 // that the track is set and being changed, rather than unset and being set for |
| 107 // the first time. |
| 108 TEST_F(OrtcRtpSenderTest, ChangeTrackWhileSending) { |
| 109 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 110 CreateAudioTrack("audio1"), rtp_transport_.get()); |
| 111 auto audio_sender = audio_sender_result.MoveValue(); |
| 112 EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok()); |
| 113 EXPECT_TRUE(audio_sender->SetTrack(CreateAudioTrack("audio2")).ok()); |
| 114 |
| 115 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 116 CreateVideoTrack("video1"), rtp_transport_.get()); |
| 117 auto video_sender = video_sender_result.MoveValue(); |
| 118 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 119 EXPECT_TRUE(video_sender->SetTrack(CreateVideoTrack("video2")).ok()); |
| 120 } |
| 121 |
| 122 // Test that track can be set to null while sending. |
| 123 TEST_F(OrtcRtpSenderTest, UnsetTrackWhileSending) { |
| 124 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 125 CreateAudioTrack("audio"), rtp_transport_.get()); |
| 126 auto audio_sender = audio_sender_result.MoveValue(); |
| 127 EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok()); |
| 128 EXPECT_TRUE(audio_sender->SetTrack(nullptr).ok()); |
| 129 |
| 130 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 131 CreateVideoTrack("video"), rtp_transport_.get()); |
| 132 auto video_sender = video_sender_result.MoveValue(); |
| 133 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 134 EXPECT_TRUE(video_sender->SetTrack(nullptr).ok()); |
| 135 } |
| 136 |
| 137 // Shouldn't be able to set an audio track on a video sender or vice versa. |
| 138 TEST_F(OrtcRtpSenderTest, SetTrackOfWrongKindFails) { |
| 139 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 140 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 141 auto audio_sender = audio_sender_result.MoveValue(); |
| 142 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 143 audio_sender->SetTrack(CreateVideoTrack("video")).type()); |
| 144 |
| 145 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 146 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 147 auto video_sender = video_sender_result.MoveValue(); |
| 148 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 149 video_sender->SetTrack(CreateAudioTrack("audio")).type()); |
| 150 } |
| 151 |
| 152 // Currently SetTransport isn't supported. When it is, replace this test with a |
| 153 // test/tests for it. |
| 154 TEST_F(OrtcRtpSenderTest, SetTransportFails) { |
| 155 rtc::FakePacketTransport fake_packet_transport("another_transport"); |
| 156 RtcpParameters rtcp_parameters; |
| 157 rtcp_parameters.mux = true; |
| 158 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 159 rtcp_parameters, &fake_packet_transport, nullptr, nullptr); |
| 160 auto rtp_transport = rtp_transport_result.MoveValue(); |
| 161 |
| 162 auto sender_result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, |
| 163 rtp_transport_.get()); |
| 164 auto sender = sender_result.MoveValue(); |
| 165 EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION, |
| 166 sender->SetTransport(rtp_transport.get()).type()); |
| 167 } |
| 168 |
| 169 TEST_F(OrtcRtpSenderTest, GetTransport) { |
| 170 auto result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, |
| 171 rtp_transport_.get()); |
| 172 EXPECT_EQ(rtp_transport_.get(), result.value()->GetTransport()); |
| 173 } |
| 174 |
| 175 // Test that "Send" causes the expected parameters to be applied to the media |
| 176 // engine level, for an audio sender. |
| 177 TEST_F(OrtcRtpSenderTest, SendAppliesAudioParametersToMediaEngine) { |
| 178 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 179 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 180 auto audio_sender = audio_sender_result.MoveValue(); |
| 181 |
| 182 // First, create parameters with all the bells and whistles. |
| 183 RtpParameters parameters; |
| 184 |
| 185 RtpCodecParameters opus_codec; |
| 186 opus_codec.name = "opus"; |
| 187 opus_codec.kind = cricket::MEDIA_TYPE_AUDIO; |
| 188 opus_codec.payload_type = 120; |
| 189 opus_codec.clock_rate.emplace(48000); |
| 190 opus_codec.num_channels.emplace(2); |
| 191 opus_codec.parameters["minptime"] = "10"; |
| 192 opus_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC); |
| 193 parameters.codecs.push_back(std::move(opus_codec)); |
| 194 |
| 195 // Add two codecs, expecting the first to be used. |
| 196 // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a |
| 197 // codec that's not at the top of the list. |
| 198 RtpCodecParameters isac_codec; |
| 199 isac_codec.name = "ISAC"; |
| 200 isac_codec.kind = cricket::MEDIA_TYPE_AUDIO; |
| 201 isac_codec.payload_type = 110; |
| 202 isac_codec.clock_rate.emplace(16000); |
| 203 parameters.codecs.push_back(std::move(isac_codec)); |
| 204 |
| 205 RtpEncodingParameters encoding; |
| 206 encoding.ssrc.emplace(0xdeadbeef); |
| 207 encoding.max_bitrate_bps.emplace(20000); |
| 208 parameters.encodings.push_back(std::move(encoding)); |
| 209 |
| 210 parameters.header_extensions.emplace_back( |
| 211 "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 3); |
| 212 |
| 213 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 214 |
| 215 // Now verify that the parameters were applied to the fake media engine layer |
| 216 // that exists below BaseChannel. |
| 217 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 218 fake_media_engine_->GetVoiceChannel(0); |
| 219 ASSERT_NE(nullptr, fake_voice_channel); |
| 220 EXPECT_TRUE(fake_voice_channel->sending()); |
| 221 |
| 222 // Verify codec parameters. |
| 223 ASSERT_GT(fake_voice_channel->send_codecs().size(), 0u); |
| 224 const cricket::AudioCodec& top_codec = fake_voice_channel->send_codecs()[0]; |
| 225 EXPECT_EQ("opus", top_codec.name); |
| 226 EXPECT_EQ(120, top_codec.id); |
| 227 EXPECT_EQ(48000, top_codec.clockrate); |
| 228 EXPECT_EQ(2u, top_codec.channels); |
| 229 ASSERT_NE(top_codec.params.end(), top_codec.params.find("minptime")); |
| 230 EXPECT_EQ("10", top_codec.params.at("minptime")); |
| 231 |
| 232 // Verify encoding parameters. |
| 233 EXPECT_EQ(20000, fake_voice_channel->max_bps()); |
| 234 ASSERT_EQ(1u, fake_voice_channel->send_streams().size()); |
| 235 const cricket::StreamParams& send_stream = |
| 236 fake_voice_channel->send_streams()[0]; |
| 237 EXPECT_EQ(1u, send_stream.ssrcs.size()); |
| 238 EXPECT_EQ(0xdeadbeef, send_stream.first_ssrc()); |
| 239 |
| 240 // Verify header extensions. |
| 241 ASSERT_EQ(1u, fake_voice_channel->send_extensions().size()); |
| 242 const RtpExtension& extension = fake_voice_channel->send_extensions()[0]; |
| 243 EXPECT_EQ("urn:ietf:params:rtp-hdrext:ssrc-audio-level", extension.uri); |
| 244 EXPECT_EQ(3, extension.id); |
| 245 } |
| 246 |
| 247 // Test that "Send" causes the expected parameters to be applied to the media |
| 248 // engine level, for a video sender. |
| 249 TEST_F(OrtcRtpSenderTest, SendAppliesVideoParametersToMediaEngine) { |
| 250 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 251 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 252 auto video_sender = video_sender_result.MoveValue(); |
| 253 |
| 254 // First, create parameters with all the bells and whistles. |
| 255 RtpParameters parameters; |
| 256 |
| 257 RtpCodecParameters vp8_codec; |
| 258 vp8_codec.name = "VP8"; |
| 259 vp8_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 260 vp8_codec.payload_type = 99; |
| 261 // Try a couple types of feedback params. "Generic NACK" is a bit of a |
| 262 // special case, so test it here. |
| 263 vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM, |
| 264 RtcpFeedbackMessageType::FIR); |
| 265 vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK, |
| 266 RtcpFeedbackMessageType::GENERIC_NACK); |
| 267 parameters.codecs.push_back(std::move(vp8_codec)); |
| 268 |
| 269 RtpCodecParameters vp8_rtx_codec; |
| 270 vp8_rtx_codec.name = "rtx"; |
| 271 vp8_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 272 vp8_rtx_codec.payload_type = 100; |
| 273 vp8_rtx_codec.parameters["apt"] = "99"; |
| 274 parameters.codecs.push_back(std::move(vp8_rtx_codec)); |
| 275 |
| 276 // Add two codecs, expecting the first to be used. |
| 277 // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a |
| 278 // codec that's not at the top of the list. |
| 279 RtpCodecParameters vp9_codec; |
| 280 vp9_codec.name = "VP9"; |
| 281 vp9_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 282 vp9_codec.payload_type = 102; |
| 283 parameters.codecs.push_back(std::move(vp9_codec)); |
| 284 |
| 285 RtpCodecParameters vp9_rtx_codec; |
| 286 vp9_rtx_codec.name = "rtx"; |
| 287 vp9_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 288 vp9_rtx_codec.payload_type = 103; |
| 289 vp9_rtx_codec.parameters["apt"] = "102"; |
| 290 parameters.codecs.push_back(std::move(vp9_rtx_codec)); |
| 291 |
| 292 RtpEncodingParameters encoding; |
| 293 encoding.ssrc.emplace(0xdeadbeef); |
| 294 encoding.rtx.emplace(0xbaadfeed); |
| 295 encoding.max_bitrate_bps.emplace(99999); |
| 296 parameters.encodings.push_back(std::move(encoding)); |
| 297 |
| 298 parameters.header_extensions.emplace_back("urn:3gpp:video-orientation", 4); |
| 299 parameters.header_extensions.emplace_back( |
| 300 "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", 6); |
| 301 |
| 302 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 303 |
| 304 // Now verify that the parameters were applied to the fake media engine layer |
| 305 // that exists below BaseChannel. |
| 306 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 307 fake_media_engine_->GetVideoChannel(0); |
| 308 ASSERT_NE(nullptr, fake_video_channel); |
| 309 EXPECT_TRUE(fake_video_channel->sending()); |
| 310 |
| 311 // Verify codec parameters. |
| 312 ASSERT_GE(fake_video_channel->send_codecs().size(), 2u); |
| 313 const cricket::VideoCodec& top_codec = fake_video_channel->send_codecs()[0]; |
| 314 EXPECT_EQ("VP8", top_codec.name); |
| 315 EXPECT_EQ(99, top_codec.id); |
| 316 EXPECT_TRUE(top_codec.feedback_params.Has({"ccm", "fir"})); |
| 317 EXPECT_TRUE(top_codec.feedback_params.Has(cricket::FeedbackParam("nack"))); |
| 318 |
| 319 const cricket::VideoCodec& rtx_codec = fake_video_channel->send_codecs()[1]; |
| 320 EXPECT_EQ("rtx", rtx_codec.name); |
| 321 EXPECT_EQ(100, rtx_codec.id); |
| 322 ASSERT_NE(rtx_codec.params.end(), rtx_codec.params.find("apt")); |
| 323 EXPECT_EQ("99", rtx_codec.params.at("apt")); |
| 324 |
| 325 // Verify encoding parameters. |
| 326 EXPECT_EQ(99999, fake_video_channel->max_bps()); |
| 327 ASSERT_EQ(1u, fake_video_channel->send_streams().size()); |
| 328 const cricket::StreamParams& send_stream = |
| 329 fake_video_channel->send_streams()[0]; |
| 330 EXPECT_EQ(2u, send_stream.ssrcs.size()); |
| 331 EXPECT_EQ(0xdeadbeef, send_stream.first_ssrc()); |
| 332 uint32_t rtx_ssrc = 0u; |
| 333 EXPECT_TRUE(send_stream.GetFidSsrc(send_stream.first_ssrc(), &rtx_ssrc)); |
| 334 EXPECT_EQ(0xbaadfeed, rtx_ssrc); |
| 335 |
| 336 // Verify header extensions. |
| 337 ASSERT_EQ(2u, fake_video_channel->send_extensions().size()); |
| 338 const RtpExtension& extension1 = fake_video_channel->send_extensions()[0]; |
| 339 EXPECT_EQ("urn:3gpp:video-orientation", extension1.uri); |
| 340 EXPECT_EQ(4, extension1.id); |
| 341 const RtpExtension& extension2 = fake_video_channel->send_extensions()[1]; |
| 342 EXPECT_EQ("http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", |
| 343 extension2.uri); |
| 344 EXPECT_EQ(6, extension2.id); |
| 345 } |
| 346 |
| 347 // Ensure that when primary or RTX SSRCs are left unset, they're generated |
| 348 // automatically. |
| 349 TEST_F(OrtcRtpSenderTest, SendGeneratesSsrcsWhenEmpty) { |
| 350 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 351 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 352 auto audio_sender = audio_sender_result.MoveValue(); |
| 353 RtpParameters parameters = MakeMinimalOpusParametersWithNoSsrc(); |
| 354 // Default RTX parameters, with no SSRC. |
| 355 parameters.encodings[0].rtx.emplace(); |
| 356 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 357 |
| 358 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 359 fake_media_engine_->GetVoiceChannel(0); |
| 360 ASSERT_NE(nullptr, fake_voice_channel); |
| 361 ASSERT_EQ(1u, fake_voice_channel->send_streams().size()); |
| 362 const cricket::StreamParams& audio_send_stream = |
| 363 fake_voice_channel->send_streams()[0]; |
| 364 EXPECT_NE(0u, audio_send_stream.first_ssrc()); |
| 365 uint32_t rtx_ssrc = 0u; |
| 366 EXPECT_TRUE( |
| 367 audio_send_stream.GetFidSsrc(audio_send_stream.first_ssrc(), &rtx_ssrc)); |
| 368 EXPECT_NE(0u, rtx_ssrc); |
| 369 EXPECT_NE(audio_send_stream.first_ssrc(), rtx_ssrc); |
| 370 |
| 371 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 372 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 373 auto video_sender = video_sender_result.MoveValue(); |
| 374 parameters = MakeMinimalVp8ParametersWithNoSsrc(); |
| 375 // Default RTX parameters, with no SSRC. |
| 376 parameters.encodings[0].rtx.emplace(); |
| 377 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 378 |
| 379 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 380 fake_media_engine_->GetVideoChannel(0); |
| 381 ASSERT_NE(nullptr, fake_video_channel); |
| 382 ASSERT_EQ(1u, fake_video_channel->send_streams().size()); |
| 383 const cricket::StreamParams& video_send_stream = |
| 384 fake_video_channel->send_streams()[0]; |
| 385 EXPECT_NE(0u, video_send_stream.first_ssrc()); |
| 386 rtx_ssrc = 0u; |
| 387 EXPECT_TRUE( |
| 388 video_send_stream.GetFidSsrc(video_send_stream.first_ssrc(), &rtx_ssrc)); |
| 389 EXPECT_NE(0u, rtx_ssrc); |
| 390 EXPECT_NE(video_send_stream.first_ssrc(), rtx_ssrc); |
| 391 EXPECT_NE(video_send_stream.first_ssrc(), audio_send_stream.first_ssrc()); |
| 392 } |
| 393 |
| 394 // Test changing both the send codec and SSRC at the same time, and verify that |
| 395 // the new parameters are applied to the media engine level. |
| 396 TEST_F(OrtcRtpSenderTest, CallingSendTwiceChangesParameters) { |
| 397 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 398 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 399 auto audio_sender = audio_sender_result.MoveValue(); |
| 400 EXPECT_TRUE( |
| 401 audio_sender->Send(MakeMinimalOpusParametersWithSsrc(0x11111111)).ok()); |
| 402 EXPECT_TRUE( |
| 403 audio_sender->Send(MakeMinimalIsacParametersWithSsrc(0x22222222)).ok()); |
| 404 |
| 405 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 406 fake_media_engine_->GetVoiceChannel(0); |
| 407 ASSERT_NE(nullptr, fake_voice_channel); |
| 408 ASSERT_GT(fake_voice_channel->send_codecs().size(), 0u); |
| 409 EXPECT_EQ("ISAC", fake_voice_channel->send_codecs()[0].name); |
| 410 ASSERT_EQ(1u, fake_voice_channel->send_streams().size()); |
| 411 EXPECT_EQ(0x22222222u, fake_voice_channel->send_streams()[0].first_ssrc()); |
| 412 |
| 413 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 414 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 415 auto video_sender = video_sender_result.MoveValue(); |
| 416 EXPECT_TRUE( |
| 417 video_sender->Send(MakeMinimalVp8ParametersWithSsrc(0x33333333)).ok()); |
| 418 EXPECT_TRUE( |
| 419 video_sender->Send(MakeMinimalVp9ParametersWithSsrc(0x44444444)).ok()); |
| 420 |
| 421 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 422 fake_media_engine_->GetVideoChannel(0); |
| 423 ASSERT_NE(nullptr, fake_video_channel); |
| 424 ASSERT_GT(fake_video_channel->send_codecs().size(), 0u); |
| 425 EXPECT_EQ("VP9", fake_video_channel->send_codecs()[0].name); |
| 426 ASSERT_EQ(1u, fake_video_channel->send_streams().size()); |
| 427 EXPECT_EQ(0x44444444u, fake_video_channel->send_streams()[0].first_ssrc()); |
| 428 } |
| 429 |
| 430 // Ensure that if the |active| flag of RtpEncodingParameters is set to false, |
| 431 // sending stops at the media engine level. |
| 432 TEST_F(OrtcRtpSenderTest, DeactivatingEncodingStopsSending) { |
| 433 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 434 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 435 auto audio_sender = audio_sender_result.MoveValue(); |
| 436 RtpParameters parameters = MakeMinimalOpusParameters(); |
| 437 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 438 |
| 439 // Expect "sending" flag to initially be true. |
| 440 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 441 fake_media_engine_->GetVoiceChannel(0); |
| 442 ASSERT_NE(nullptr, fake_voice_channel); |
| 443 EXPECT_TRUE(fake_voice_channel->sending()); |
| 444 |
| 445 // Deactivate encoding and expect it to change to false. |
| 446 parameters.encodings[0].active = false; |
| 447 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 448 EXPECT_FALSE(fake_voice_channel->sending()); |
| 449 |
| 450 // Try the same thing for video now. |
| 451 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 452 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 453 auto video_sender = video_sender_result.MoveValue(); |
| 454 parameters = MakeMinimalVp8Parameters(); |
| 455 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 456 |
| 457 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 458 fake_media_engine_->GetVideoChannel(0); |
| 459 ASSERT_NE(nullptr, fake_video_channel); |
| 460 EXPECT_TRUE(fake_video_channel->sending()); |
| 461 |
| 462 parameters.encodings[0].active = false; |
| 463 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 464 EXPECT_FALSE(fake_video_channel->sending()); |
| 465 } |
| 466 |
| 467 // Ensure that calling Send with an empty list of encodings causes send streams |
| 468 // at the media engine level to be cleared. |
| 469 TEST_F(OrtcRtpSenderTest, CallingSendWithEmptyEncodingsClearsSendStreams) { |
| 470 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 471 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 472 auto audio_sender = audio_sender_result.MoveValue(); |
| 473 RtpParameters parameters = MakeMinimalOpusParameters(); |
| 474 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 475 parameters.encodings.clear(); |
| 476 EXPECT_TRUE(audio_sender->Send(parameters).ok()); |
| 477 |
| 478 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 479 fake_media_engine_->GetVoiceChannel(0); |
| 480 ASSERT_NE(nullptr, fake_voice_channel); |
| 481 EXPECT_TRUE(fake_voice_channel->send_streams().empty()); |
| 482 |
| 483 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 484 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 485 auto video_sender = video_sender_result.MoveValue(); |
| 486 parameters = MakeMinimalVp8Parameters(); |
| 487 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 488 parameters.encodings.clear(); |
| 489 EXPECT_TRUE(video_sender->Send(parameters).ok()); |
| 490 |
| 491 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 492 fake_media_engine_->GetVideoChannel(0); |
| 493 ASSERT_NE(nullptr, fake_video_channel); |
| 494 EXPECT_TRUE(fake_video_channel->send_streams().empty()); |
| 495 } |
| 496 |
| 497 // These errors should be covered by rtpparametersconversion_unittest.cc, but |
| 498 // we should at least test that those errors are propogated from calls to Send, |
| 499 // with a few examples. |
| 500 TEST_F(OrtcRtpSenderTest, SendReturnsErrorOnInvalidParameters) { |
| 501 auto result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, |
| 502 rtp_transport_.get()); |
| 503 auto sender = result.MoveValue(); |
| 504 // NACK feedback missing message type. |
| 505 RtpParameters invalid_feedback = MakeMinimalVp8Parameters(); |
| 506 invalid_feedback.codecs[0].rtcp_feedback.emplace_back(RtcpFeedbackType::NACK); |
| 507 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 508 sender->Send(invalid_feedback).type()); |
| 509 // Negative payload type. |
| 510 RtpParameters invalid_pt = MakeMinimalVp8Parameters(); |
| 511 invalid_pt.codecs[0].payload_type = -1; |
| 512 EXPECT_EQ(RTCErrorType::INVALID_RANGE, sender->Send(invalid_pt).type()); |
| 513 // Duplicate codec payload types. |
| 514 RtpParameters duplicate_payload_types = MakeMinimalVp8Parameters(); |
| 515 duplicate_payload_types.codecs.push_back(duplicate_payload_types.codecs[0]); |
| 516 duplicate_payload_types.codecs.back().name = "VP9"; |
| 517 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 518 sender->Send(duplicate_payload_types).type()); |
| 519 } |
| 520 |
| 521 // Two senders using the same transport shouldn't be able to use the same |
| 522 // payload type to refer to different codecs, same header extension IDs to |
| 523 // refer to different extensions, or same SSRC. |
| 524 TEST_F(OrtcRtpSenderTest, SendReturnsErrorOnIdConflicts) { |
| 525 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 526 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 527 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 528 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 529 auto audio_sender = audio_sender_result.MoveValue(); |
| 530 auto video_sender = video_sender_result.MoveValue(); |
| 531 |
| 532 // First test payload type conflict. |
| 533 RtpParameters audio_parameters = MakeMinimalOpusParameters(); |
| 534 RtpParameters video_parameters = MakeMinimalVp8Parameters(); |
| 535 audio_parameters.codecs[0].payload_type = 100; |
| 536 video_parameters.codecs[0].payload_type = 100; |
| 537 EXPECT_TRUE(audio_sender->Send(audio_parameters).ok()); |
| 538 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 539 video_sender->Send(video_parameters).type()); |
| 540 |
| 541 // Test header extension ID conflict. |
| 542 video_parameters.codecs[0].payload_type = 110; |
| 543 audio_parameters.header_extensions.emplace_back("foo", 4); |
| 544 video_parameters.header_extensions.emplace_back("bar", 4); |
| 545 EXPECT_TRUE(audio_sender->Send(audio_parameters).ok()); |
| 546 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 547 video_sender->Send(video_parameters).type()); |
| 548 |
| 549 // Test SSRC conflict. Have an RTX SSRC that conflicts with a primary SSRC |
| 550 // for extra challenge. |
| 551 video_parameters.header_extensions[0].uri = "foo"; |
| 552 audio_parameters.encodings[0].ssrc.emplace(0xdeadbeef); |
| 553 video_parameters.encodings[0].ssrc.emplace(0xabbaabba); |
| 554 video_parameters.encodings[0].rtx.emplace(0xdeadbeef); |
| 555 EXPECT_TRUE(audio_sender->Send(audio_parameters).ok()); |
| 556 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 557 video_sender->Send(video_parameters).type()); |
| 558 |
| 559 // Sanity check that parameters can be set if the conflicts are all resolved. |
| 560 video_parameters.encodings[0].rtx->ssrc.emplace(0xbaadf00d); |
| 561 EXPECT_TRUE(video_sender->Send(video_parameters).ok()); |
| 562 } |
| 563 |
| 564 // Ensure that deleting a sender causes send streams at the media engine level |
| 565 // to be cleared. |
| 566 TEST_F(OrtcRtpSenderTest, DeletingSenderClearsSendStreams) { |
| 567 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 568 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 569 auto audio_sender = audio_sender_result.MoveValue(); |
| 570 EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok()); |
| 571 |
| 572 // Also create an audio receiver, to prevent the voice channel from being |
| 573 // completely deleted. |
| 574 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 575 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 576 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 577 EXPECT_TRUE(audio_receiver->Receive(MakeMinimalOpusParameters()).ok()); |
| 578 |
| 579 audio_sender.reset(nullptr); |
| 580 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 581 fake_media_engine_->GetVoiceChannel(0); |
| 582 ASSERT_NE(nullptr, fake_voice_channel); |
| 583 EXPECT_TRUE(fake_voice_channel->send_streams().empty()); |
| 584 |
| 585 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 586 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 587 auto video_sender = video_sender_result.MoveValue(); |
| 588 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 589 |
| 590 // Also create an video receiver, to prevent the video channel from being |
| 591 // completely deleted. |
| 592 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 593 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 594 auto video_receiver = video_receiver_result.MoveValue(); |
| 595 EXPECT_TRUE(video_receiver->Receive(MakeMinimalVp8Parameters()).ok()); |
| 596 |
| 597 video_sender.reset(nullptr); |
| 598 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 599 fake_media_engine_->GetVideoChannel(0); |
| 600 ASSERT_NE(nullptr, fake_video_channel); |
| 601 EXPECT_TRUE(fake_video_channel->send_streams().empty()); |
| 602 } |
| 603 |
| 604 // If Send hasn't been called, GetParameters should return empty parameters. |
| 605 TEST_F(OrtcRtpSenderTest, GetDefaultParameters) { |
| 606 auto result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_AUDIO, |
| 607 rtp_transport_.get()); |
| 608 EXPECT_EQ(RtpParameters(), result.value()->GetParameters()); |
| 609 result = ortc_factory_->CreateRtpSender(cricket::MEDIA_TYPE_VIDEO, |
| 610 rtp_transport_.get()); |
| 611 EXPECT_EQ(RtpParameters(), result.value()->GetParameters()); |
| 612 } |
| 613 |
| 614 // Test that GetParameters returns the last parameters passed into Send, along |
| 615 // with the implementation-default values filled in where they were left unset. |
| 616 TEST_F(OrtcRtpSenderTest, |
| 617 GetParametersReturnsLastSetParametersWithDefaultsFilled) { |
| 618 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 619 CreateAudioTrack("audio"), rtp_transport_.get()); |
| 620 auto audio_sender = audio_sender_result.MoveValue(); |
| 621 |
| 622 RtpParameters opus_parameters = MakeMinimalOpusParameters(); |
| 623 EXPECT_TRUE(audio_sender->Send(opus_parameters).ok()); |
| 624 EXPECT_EQ(opus_parameters, audio_sender->GetParameters()); |
| 625 |
| 626 RtpParameters isac_parameters = MakeMinimalIsacParameters(); |
| 627 // Sanity check that num_channels actually is left unset. |
| 628 ASSERT_FALSE(isac_parameters.codecs[0].num_channels); |
| 629 EXPECT_TRUE(audio_sender->Send(isac_parameters).ok()); |
| 630 // Should be filled with a default "num channels" of 1. |
| 631 // TODO(deadbeef): This should actually default to 2 for some codecs. Update |
| 632 // this test once that's implemented. |
| 633 isac_parameters.codecs[0].num_channels.emplace(1); |
| 634 EXPECT_EQ(isac_parameters, audio_sender->GetParameters()); |
| 635 |
| 636 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 637 CreateVideoTrack("video"), rtp_transport_.get()); |
| 638 auto video_sender = video_sender_result.MoveValue(); |
| 639 |
| 640 RtpParameters vp8_parameters = MakeMinimalVp8Parameters(); |
| 641 // Sanity check that clock_rate actually is left unset. |
| 642 EXPECT_TRUE(video_sender->Send(vp8_parameters).ok()); |
| 643 // Should be filled with a default clock rate of 90000. |
| 644 vp8_parameters.codecs[0].clock_rate.emplace(90000); |
| 645 EXPECT_EQ(vp8_parameters, video_sender->GetParameters()); |
| 646 |
| 647 RtpParameters vp9_parameters = MakeMinimalVp9Parameters(); |
| 648 // Sanity check that clock_rate actually is left unset. |
| 649 EXPECT_TRUE(video_sender->Send(vp9_parameters).ok()); |
| 650 // Should be filled with a default clock rate of 90000. |
| 651 vp9_parameters.codecs[0].clock_rate.emplace(90000); |
| 652 EXPECT_EQ(vp9_parameters, video_sender->GetParameters()); |
| 653 } |
| 654 |
| 655 TEST_F(OrtcRtpSenderTest, GetKind) { |
| 656 // Construct one sender from the "kind" enum and another from a track. |
| 657 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 658 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 659 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 660 CreateVideoTrack("video"), rtp_transport_.get()); |
| 661 auto audio_sender = audio_sender_result.MoveValue(); |
| 662 auto video_sender = video_sender_result.MoveValue(); |
| 663 EXPECT_EQ(cricket::MEDIA_TYPE_AUDIO, audio_sender->GetKind()); |
| 664 EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, video_sender->GetKind()); |
| 665 } |
| 666 |
| 667 } // namespace webrtc |
OLD | NEW |