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 RtpReceiver using only the public interface, |
| 23 // and verifies that it 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 OrtcRtpReceiverTest : public testing::Test { |
| 30 public: |
| 31 OrtcRtpReceiverTest() : fake_packet_transport_("fake") { |
| 32 fake_media_engine_ = new cricket::FakeMediaEngine(); |
| 33 // Note: This doesn't need to use fake network classes, since we already |
| 34 // use FakePacketTransport. |
| 35 auto ortc_factory_result = OrtcFactory::Create( |
| 36 nullptr, nullptr, nullptr, nullptr, nullptr, |
| 37 std::unique_ptr<cricket::MediaEngineInterface>(fake_media_engine_)); |
| 38 ortc_factory_ = ortc_factory_result.MoveValue(); |
| 39 RtcpParameters rtcp_parameters; |
| 40 rtcp_parameters.mux = true; |
| 41 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 42 rtcp_parameters, &fake_packet_transport_, nullptr, nullptr); |
| 43 rtp_transport_ = rtp_transport_result.MoveValue(); |
| 44 } |
| 45 |
| 46 protected: |
| 47 // Owned by |ortc_factory_|. |
| 48 cricket::FakeMediaEngine* fake_media_engine_; |
| 49 rtc::FakePacketTransport fake_packet_transport_; |
| 50 std::unique_ptr<OrtcFactoryInterface> ortc_factory_; |
| 51 std::unique_ptr<RtpTransportInterface> rtp_transport_; |
| 52 }; |
| 53 |
| 54 // See ortcrtpreceiverinterface.h for the current expectations of what GetTrack |
| 55 // will return after calls to Receive. |
| 56 // TODO(deadbeef): Replace this test when the non-standard behavior is fixed |
| 57 // and GetTrack starts returning the same track for the lifetime of the |
| 58 // receiver. |
| 59 TEST_F(OrtcRtpReceiverTest, GetTrack) { |
| 60 auto receiver_result = ortc_factory_->CreateRtpReceiver( |
| 61 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 62 ASSERT_TRUE(receiver_result.ok()); |
| 63 auto receiver = receiver_result.MoveValue(); |
| 64 |
| 65 // Track initially expected to be null. |
| 66 EXPECT_EQ(nullptr, receiver_result.value().get()); |
| 67 |
| 68 EXPECT_TRUE(receiver->Receive(MakeMinimalVp8ParametersWithNoSsrc()).ok()); |
| 69 auto initial_track = receiver->GetTrack(); |
| 70 EXPECT_NE(nullptr, initial_track); |
| 71 |
| 72 // Codec changing but SSRC (or lack thereof) isn't; shouldn't create new track |
| 73 EXPECT_TRUE(receiver->Receive(MakeMinimalVp9ParametersWithNoSsrc()).ok()); |
| 74 EXPECT_EQ(initial_track, receiver->GetTrack()); |
| 75 |
| 76 // Explicitly set SSRC and expect a different track. |
| 77 EXPECT_TRUE( |
| 78 receiver->Receive(MakeMinimalVp9ParametersWithSsrc(0xdeadbeef)).ok()); |
| 79 auto next_track = receiver->GetTrack(); |
| 80 EXPECT_NE(next_track, initial_track); |
| 81 |
| 82 // Deactivating the encoding shouldn't change the track. |
| 83 RtpParameters inactive_encoding = |
| 84 MakeMinimalVp9ParametersWithSsrc(0xdeadbeef); |
| 85 inactive_encoding.encodings[0].active = false; |
| 86 EXPECT_TRUE(receiver->Receive(inactive_encoding).ok()); |
| 87 EXPECT_EQ(next_track, receiver->GetTrack()); |
| 88 |
| 89 // Removing all encodings *is* expected to clear the track. |
| 90 RtpParameters no_encodings = MakeMinimalVp9ParametersWithSsrc(0xdeadbeef); |
| 91 no_encodings.encodings.clear(); |
| 92 EXPECT_TRUE(receiver->Receive(no_encodings).ok()); |
| 93 EXPECT_EQ(nullptr, receiver->GetTrack()); |
| 94 } |
| 95 |
| 96 // Currently SetTransport isn't supported. When it is, replace this test with a |
| 97 // test/tests for it. |
| 98 TEST_F(OrtcRtpReceiverTest, SetTransportFails) { |
| 99 rtc::FakePacketTransport fake_packet_transport("another_transport"); |
| 100 RtcpParameters rtcp_parameters; |
| 101 rtcp_parameters.mux = true; |
| 102 auto rtp_transport_result = ortc_factory_->CreateRtpTransport( |
| 103 rtcp_parameters, &fake_packet_transport, nullptr, nullptr); |
| 104 auto rtp_transport = rtp_transport_result.MoveValue(); |
| 105 |
| 106 auto receiver_result = ortc_factory_->CreateRtpReceiver( |
| 107 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 108 auto receiver = receiver_result.MoveValue(); |
| 109 EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION, |
| 110 receiver->SetTransport(rtp_transport.get()).type()); |
| 111 } |
| 112 |
| 113 TEST_F(OrtcRtpReceiverTest, GetTransport) { |
| 114 auto result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO, |
| 115 rtp_transport_.get()); |
| 116 EXPECT_EQ(rtp_transport_.get(), result.value()->GetTransport()); |
| 117 } |
| 118 |
| 119 // Test that "Receive" causes the expected parameters to be applied to the media |
| 120 // engine level, for an audio receiver. |
| 121 TEST_F(OrtcRtpReceiverTest, ReceiveAppliesAudioParametersToMediaEngine) { |
| 122 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 123 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 124 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 125 |
| 126 // First, create parameters with all the bells and whistles. |
| 127 RtpParameters parameters; |
| 128 |
| 129 RtpCodecParameters opus_codec; |
| 130 opus_codec.name = "opus"; |
| 131 opus_codec.kind = cricket::MEDIA_TYPE_AUDIO; |
| 132 opus_codec.payload_type = 120; |
| 133 opus_codec.clock_rate.emplace(48000); |
| 134 opus_codec.num_channels.emplace(2); |
| 135 opus_codec.parameters["minptime"] = "10"; |
| 136 opus_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC); |
| 137 parameters.codecs.push_back(std::move(opus_codec)); |
| 138 |
| 139 // Add two codecs, expecting the first to be used. |
| 140 // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a |
| 141 // codec that's not at the top of the list. |
| 142 RtpCodecParameters isac_codec; |
| 143 isac_codec.name = "ISAC"; |
| 144 isac_codec.kind = cricket::MEDIA_TYPE_AUDIO; |
| 145 isac_codec.payload_type = 110; |
| 146 isac_codec.clock_rate.emplace(16000); |
| 147 parameters.codecs.push_back(std::move(isac_codec)); |
| 148 |
| 149 RtpEncodingParameters encoding; |
| 150 encoding.ssrc.emplace(0xdeadbeef); |
| 151 parameters.encodings.push_back(std::move(encoding)); |
| 152 |
| 153 parameters.header_extensions.emplace_back( |
| 154 "urn:ietf:params:rtp-hdrext:ssrc-audio-level", 3); |
| 155 |
| 156 EXPECT_TRUE(audio_receiver->Receive(parameters).ok()); |
| 157 |
| 158 // Now verify that the parameters were applied to the fake media engine layer |
| 159 // that exists below BaseChannel. |
| 160 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 161 fake_media_engine_->GetVoiceChannel(0); |
| 162 ASSERT_NE(nullptr, fake_voice_channel); |
| 163 EXPECT_TRUE(fake_voice_channel->playout()); |
| 164 |
| 165 // Verify codec parameters. |
| 166 ASSERT_GT(fake_voice_channel->recv_codecs().size(), 0u); |
| 167 const cricket::AudioCodec& top_codec = fake_voice_channel->recv_codecs()[0]; |
| 168 EXPECT_EQ("opus", top_codec.name); |
| 169 EXPECT_EQ(120, top_codec.id); |
| 170 EXPECT_EQ(48000, top_codec.clockrate); |
| 171 EXPECT_EQ(2u, top_codec.channels); |
| 172 ASSERT_NE(top_codec.params.end(), top_codec.params.find("minptime")); |
| 173 EXPECT_EQ("10", top_codec.params.at("minptime")); |
| 174 |
| 175 // Verify encoding parameters. |
| 176 ASSERT_EQ(1u, fake_voice_channel->recv_streams().size()); |
| 177 const cricket::StreamParams& recv_stream = |
| 178 fake_voice_channel->recv_streams()[0]; |
| 179 EXPECT_EQ(1u, recv_stream.ssrcs.size()); |
| 180 EXPECT_EQ(0xdeadbeef, recv_stream.first_ssrc()); |
| 181 |
| 182 // Verify header extensions. |
| 183 ASSERT_EQ(1u, fake_voice_channel->recv_extensions().size()); |
| 184 const RtpExtension& extension = fake_voice_channel->recv_extensions()[0]; |
| 185 EXPECT_EQ("urn:ietf:params:rtp-hdrext:ssrc-audio-level", extension.uri); |
| 186 EXPECT_EQ(3, extension.id); |
| 187 } |
| 188 |
| 189 // Test that "Receive" causes the expected parameters to be applied to the media |
| 190 // engine level, for a video receiver. |
| 191 TEST_F(OrtcRtpReceiverTest, ReceiveAppliesVideoParametersToMediaEngine) { |
| 192 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 193 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 194 auto video_receiver = video_receiver_result.MoveValue(); |
| 195 |
| 196 // First, create parameters with all the bells and whistles. |
| 197 RtpParameters parameters; |
| 198 |
| 199 RtpCodecParameters vp8_codec; |
| 200 vp8_codec.name = "VP8"; |
| 201 vp8_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 202 vp8_codec.payload_type = 99; |
| 203 // Try a couple types of feedback params. "Generic NACK" is a bit of a |
| 204 // special case, so test it here. |
| 205 vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM, |
| 206 RtcpFeedbackMessageType::FIR); |
| 207 vp8_codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK, |
| 208 RtcpFeedbackMessageType::GENERIC_NACK); |
| 209 parameters.codecs.push_back(std::move(vp8_codec)); |
| 210 |
| 211 RtpCodecParameters vp8_rtx_codec; |
| 212 vp8_rtx_codec.name = "rtx"; |
| 213 vp8_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 214 vp8_rtx_codec.payload_type = 100; |
| 215 vp8_rtx_codec.parameters["apt"] = "99"; |
| 216 parameters.codecs.push_back(std::move(vp8_rtx_codec)); |
| 217 |
| 218 // Add two codecs, expecting the first to be used. |
| 219 // TODO(deadbeef): Once "codec_payload_type" is supported, use it to select a |
| 220 // codec that's not at the top of the list. |
| 221 RtpCodecParameters vp9_codec; |
| 222 vp9_codec.name = "VP9"; |
| 223 vp9_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 224 vp9_codec.payload_type = 102; |
| 225 parameters.codecs.push_back(std::move(vp9_codec)); |
| 226 |
| 227 RtpCodecParameters vp9_rtx_codec; |
| 228 vp9_rtx_codec.name = "rtx"; |
| 229 vp9_rtx_codec.kind = cricket::MEDIA_TYPE_VIDEO; |
| 230 vp9_rtx_codec.payload_type = 103; |
| 231 vp9_rtx_codec.parameters["apt"] = "102"; |
| 232 parameters.codecs.push_back(std::move(vp9_rtx_codec)); |
| 233 |
| 234 RtpEncodingParameters encoding; |
| 235 encoding.ssrc.emplace(0xdeadbeef); |
| 236 encoding.rtx.emplace(0xbaadfeed); |
| 237 parameters.encodings.push_back(std::move(encoding)); |
| 238 |
| 239 parameters.header_extensions.emplace_back("urn:3gpp:video-orientation", 4); |
| 240 parameters.header_extensions.emplace_back( |
| 241 "http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", 6); |
| 242 |
| 243 EXPECT_TRUE(video_receiver->Receive(parameters).ok()); |
| 244 |
| 245 // Now verify that the parameters were applied to the fake media engine layer |
| 246 // that exists below BaseChannel. |
| 247 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 248 fake_media_engine_->GetVideoChannel(0); |
| 249 ASSERT_NE(nullptr, fake_video_channel); |
| 250 |
| 251 // Verify codec parameters. |
| 252 ASSERT_GE(fake_video_channel->recv_codecs().size(), 2u); |
| 253 const cricket::VideoCodec& top_codec = fake_video_channel->recv_codecs()[0]; |
| 254 EXPECT_EQ("VP8", top_codec.name); |
| 255 EXPECT_EQ(99, top_codec.id); |
| 256 EXPECT_TRUE(top_codec.feedback_params.Has({"ccm", "fir"})); |
| 257 EXPECT_TRUE(top_codec.feedback_params.Has(cricket::FeedbackParam("nack"))); |
| 258 |
| 259 const cricket::VideoCodec& rtx_codec = fake_video_channel->recv_codecs()[1]; |
| 260 EXPECT_EQ("rtx", rtx_codec.name); |
| 261 EXPECT_EQ(100, rtx_codec.id); |
| 262 ASSERT_NE(rtx_codec.params.end(), rtx_codec.params.find("apt")); |
| 263 EXPECT_EQ("99", rtx_codec.params.at("apt")); |
| 264 |
| 265 // Verify encoding parameters. |
| 266 ASSERT_EQ(1u, fake_video_channel->recv_streams().size()); |
| 267 const cricket::StreamParams& recv_stream = |
| 268 fake_video_channel->recv_streams()[0]; |
| 269 EXPECT_EQ(2u, recv_stream.ssrcs.size()); |
| 270 EXPECT_EQ(0xdeadbeef, recv_stream.first_ssrc()); |
| 271 uint32_t rtx_ssrc = 0u; |
| 272 EXPECT_TRUE(recv_stream.GetFidSsrc(recv_stream.first_ssrc(), &rtx_ssrc)); |
| 273 EXPECT_EQ(0xbaadfeed, rtx_ssrc); |
| 274 |
| 275 // Verify header extensions. |
| 276 ASSERT_EQ(2u, fake_video_channel->recv_extensions().size()); |
| 277 const RtpExtension& extension1 = fake_video_channel->recv_extensions()[0]; |
| 278 EXPECT_EQ("urn:3gpp:video-orientation", extension1.uri); |
| 279 EXPECT_EQ(4, extension1.id); |
| 280 const RtpExtension& extension2 = fake_video_channel->recv_extensions()[1]; |
| 281 EXPECT_EQ("http://www.webrtc.org/experiments/rtp-hdrext/playout-delay", |
| 282 extension2.uri); |
| 283 EXPECT_EQ(6, extension2.id); |
| 284 } |
| 285 |
| 286 // Test changing both the receive codec and SSRC at the same time, and verify |
| 287 // that the new parameters are applied to the media engine level. |
| 288 TEST_F(OrtcRtpReceiverTest, CallingReceiveTwiceChangesParameters) { |
| 289 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 290 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 291 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 292 RTCError error = |
| 293 audio_receiver->Receive(MakeMinimalOpusParametersWithSsrc(0x11111111)); |
| 294 EXPECT_TRUE(error.ok()); |
| 295 error = |
| 296 audio_receiver->Receive(MakeMinimalIsacParametersWithSsrc(0x22222222)); |
| 297 EXPECT_TRUE(error.ok()); |
| 298 |
| 299 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 300 fake_media_engine_->GetVoiceChannel(0); |
| 301 ASSERT_NE(nullptr, fake_voice_channel); |
| 302 ASSERT_GT(fake_voice_channel->recv_codecs().size(), 0u); |
| 303 EXPECT_EQ("ISAC", fake_voice_channel->recv_codecs()[0].name); |
| 304 ASSERT_EQ(1u, fake_voice_channel->recv_streams().size()); |
| 305 EXPECT_EQ(0x22222222u, fake_voice_channel->recv_streams()[0].first_ssrc()); |
| 306 |
| 307 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 308 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 309 auto video_receiver = video_receiver_result.MoveValue(); |
| 310 error = video_receiver->Receive(MakeMinimalVp8ParametersWithSsrc(0x33333333)); |
| 311 EXPECT_TRUE(error.ok()); |
| 312 error = video_receiver->Receive(MakeMinimalVp9ParametersWithSsrc(0x44444444)); |
| 313 EXPECT_TRUE(error.ok()); |
| 314 |
| 315 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 316 fake_media_engine_->GetVideoChannel(0); |
| 317 ASSERT_NE(nullptr, fake_video_channel); |
| 318 ASSERT_GT(fake_video_channel->recv_codecs().size(), 0u); |
| 319 EXPECT_EQ("VP9", fake_video_channel->recv_codecs()[0].name); |
| 320 ASSERT_EQ(1u, fake_video_channel->recv_streams().size()); |
| 321 EXPECT_EQ(0x44444444u, fake_video_channel->recv_streams()[0].first_ssrc()); |
| 322 } |
| 323 |
| 324 // Ensure that if the |active| flag of RtpEncodingParameters is set to false, |
| 325 // playout stops at the media engine level. Note that this is only applicable |
| 326 // to audio (at least currently). |
| 327 TEST_F(OrtcRtpReceiverTest, DeactivatingEncodingStopsPlayout) { |
| 328 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 329 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 330 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 331 RtpParameters parameters = MakeMinimalOpusParameters(); |
| 332 EXPECT_TRUE(audio_receiver->Receive(parameters).ok()); |
| 333 |
| 334 // Expect "playout" flag to initially be true. |
| 335 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 336 fake_media_engine_->GetVoiceChannel(0); |
| 337 ASSERT_NE(nullptr, fake_voice_channel); |
| 338 EXPECT_TRUE(fake_voice_channel->playout()); |
| 339 |
| 340 // Deactivate encoding and expect it to change to false. |
| 341 parameters.encodings[0].active = false; |
| 342 EXPECT_TRUE(audio_receiver->Receive(parameters).ok()); |
| 343 EXPECT_FALSE(fake_voice_channel->playout()); |
| 344 } |
| 345 |
| 346 // Ensure that calling Receive with an empty list of encodings causes receive |
| 347 // streams at the media engine level to be cleared. |
| 348 TEST_F(OrtcRtpReceiverTest, |
| 349 CallingReceiveWithEmptyEncodingsClearsReceiveStreams) { |
| 350 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 351 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 352 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 353 RtpParameters parameters = MakeMinimalOpusParameters(); |
| 354 EXPECT_TRUE(audio_receiver->Receive(parameters).ok()); |
| 355 parameters.encodings.clear(); |
| 356 EXPECT_TRUE(audio_receiver->Receive(parameters).ok()); |
| 357 |
| 358 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 359 fake_media_engine_->GetVoiceChannel(0); |
| 360 ASSERT_NE(nullptr, fake_voice_channel); |
| 361 EXPECT_TRUE(fake_voice_channel->recv_streams().empty()); |
| 362 |
| 363 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 364 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 365 auto video_receiver = video_receiver_result.MoveValue(); |
| 366 parameters = MakeMinimalVp8Parameters(); |
| 367 EXPECT_TRUE(video_receiver->Receive(parameters).ok()); |
| 368 parameters.encodings.clear(); |
| 369 EXPECT_TRUE(video_receiver->Receive(parameters).ok()); |
| 370 |
| 371 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 372 fake_media_engine_->GetVideoChannel(0); |
| 373 ASSERT_NE(nullptr, fake_video_channel); |
| 374 EXPECT_TRUE(fake_video_channel->recv_streams().empty()); |
| 375 } |
| 376 |
| 377 // These errors should be covered by rtpparametersconversion_unittest.cc, but |
| 378 // we should at least test that those errors are propogated from calls to |
| 379 // Receive, with a few examples. |
| 380 TEST_F(OrtcRtpReceiverTest, ReceiveReturnsErrorOnInvalidParameters) { |
| 381 auto result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO, |
| 382 rtp_transport_.get()); |
| 383 auto receiver = result.MoveValue(); |
| 384 // CCM feedback missing message type. |
| 385 RtpParameters invalid_feedback = MakeMinimalOpusParameters(); |
| 386 invalid_feedback.codecs[0].rtcp_feedback.emplace_back(RtcpFeedbackType::CCM); |
| 387 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 388 receiver->Receive(invalid_feedback).type()); |
| 389 // Payload type greater than 127. |
| 390 RtpParameters invalid_pt = MakeMinimalOpusParameters(); |
| 391 invalid_pt.codecs[0].payload_type = 128; |
| 392 EXPECT_EQ(RTCErrorType::INVALID_RANGE, receiver->Receive(invalid_pt).type()); |
| 393 // Duplicate header extension IDs. |
| 394 RtpParameters duplicate_ids = MakeMinimalOpusParameters(); |
| 395 duplicate_ids.header_extensions.emplace_back("foo", 5); |
| 396 duplicate_ids.header_extensions.emplace_back("bar", 5); |
| 397 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 398 receiver->Receive(duplicate_ids).type()); |
| 399 } |
| 400 |
| 401 // Two receivers using the same transport shouldn't be able to use the same |
| 402 // payload type to refer to different codecs, same header extension IDs to |
| 403 // refer to different extensions, or same SSRC. |
| 404 TEST_F(OrtcRtpReceiverTest, ReceiveReturnsErrorOnIdConflicts) { |
| 405 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 406 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 407 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 408 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 409 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 410 auto video_receiver = video_receiver_result.MoveValue(); |
| 411 |
| 412 // First test payload type conflict. |
| 413 RtpParameters audio_parameters = MakeMinimalOpusParameters(); |
| 414 RtpParameters video_parameters = MakeMinimalVp8Parameters(); |
| 415 audio_parameters.codecs[0].payload_type = 100; |
| 416 video_parameters.codecs[0].payload_type = 100; |
| 417 EXPECT_TRUE(audio_receiver->Receive(audio_parameters).ok()); |
| 418 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 419 video_receiver->Receive(video_parameters).type()); |
| 420 |
| 421 // Test header extension ID conflict. |
| 422 video_parameters.codecs[0].payload_type = 110; |
| 423 audio_parameters.header_extensions.emplace_back("foo", 4); |
| 424 video_parameters.header_extensions.emplace_back("bar", 4); |
| 425 EXPECT_TRUE(audio_receiver->Receive(audio_parameters).ok()); |
| 426 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 427 video_receiver->Receive(video_parameters).type()); |
| 428 |
| 429 // Test SSRC conflict. Have an RTX SSRC that conflicts with a primary SSRC |
| 430 // for extra challenge. |
| 431 video_parameters.header_extensions[0].uri = "foo"; |
| 432 audio_parameters.encodings[0].ssrc.emplace(0xabbaabba); |
| 433 audio_parameters.encodings[0].rtx.emplace(0xdeadbeef); |
| 434 video_parameters.encodings[0].ssrc.emplace(0xdeadbeef); |
| 435 EXPECT_TRUE(audio_receiver->Receive(audio_parameters).ok()); |
| 436 EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, |
| 437 video_receiver->Receive(video_parameters).type()); |
| 438 |
| 439 // Sanity check that parameters can be set if the conflicts are all resolved. |
| 440 video_parameters.encodings[0].ssrc.emplace(0xbaadf00d); |
| 441 EXPECT_TRUE(video_receiver->Receive(video_parameters).ok()); |
| 442 } |
| 443 |
| 444 // Ensure that deleting a receiver causes receive streams at the media engine |
| 445 // level to be cleared. |
| 446 TEST_F(OrtcRtpReceiverTest, DeletingReceiverClearsReceiveStreams) { |
| 447 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 448 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 449 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 450 EXPECT_TRUE(audio_receiver->Receive(MakeMinimalOpusParameters()).ok()); |
| 451 |
| 452 // Also create an audio sender, to prevent the voice channel from being |
| 453 // completely deleted. |
| 454 auto audio_sender_result = ortc_factory_->CreateRtpSender( |
| 455 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 456 auto audio_sender = audio_sender_result.MoveValue(); |
| 457 EXPECT_TRUE(audio_sender->Send(MakeMinimalOpusParameters()).ok()); |
| 458 |
| 459 audio_receiver.reset(nullptr); |
| 460 cricket::FakeVoiceMediaChannel* fake_voice_channel = |
| 461 fake_media_engine_->GetVoiceChannel(0); |
| 462 ASSERT_NE(nullptr, fake_voice_channel); |
| 463 EXPECT_TRUE(fake_voice_channel->recv_streams().empty()); |
| 464 |
| 465 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 466 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 467 auto video_receiver = video_receiver_result.MoveValue(); |
| 468 EXPECT_TRUE(video_receiver->Receive(MakeMinimalVp8Parameters()).ok()); |
| 469 |
| 470 // Also create an video sender, to prevent the video channel from being |
| 471 // completely deleted. |
| 472 auto video_sender_result = ortc_factory_->CreateRtpSender( |
| 473 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 474 auto video_sender = video_sender_result.MoveValue(); |
| 475 EXPECT_TRUE(video_sender->Send(MakeMinimalVp8Parameters()).ok()); |
| 476 |
| 477 video_receiver.reset(nullptr); |
| 478 cricket::FakeVideoMediaChannel* fake_video_channel = |
| 479 fake_media_engine_->GetVideoChannel(0); |
| 480 ASSERT_NE(nullptr, fake_video_channel); |
| 481 EXPECT_TRUE(fake_video_channel->recv_streams().empty()); |
| 482 } |
| 483 |
| 484 // If Receive hasn't been called, GetParameters should return empty parameters. |
| 485 TEST_F(OrtcRtpReceiverTest, GetDefaultParameters) { |
| 486 auto result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_AUDIO, |
| 487 rtp_transport_.get()); |
| 488 EXPECT_EQ(RtpParameters(), result.value()->GetParameters()); |
| 489 result = ortc_factory_->CreateRtpReceiver(cricket::MEDIA_TYPE_VIDEO, |
| 490 rtp_transport_.get()); |
| 491 EXPECT_EQ(RtpParameters(), result.value()->GetParameters()); |
| 492 } |
| 493 |
| 494 // Test that GetParameters returns the last parameters passed into Receive, |
| 495 // along with the implementation-default values filled in where they were left |
| 496 // unset. |
| 497 TEST_F(OrtcRtpReceiverTest, |
| 498 GetParametersReturnsLastSetParametersWithDefaultsFilled) { |
| 499 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 500 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 501 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 502 |
| 503 RtpParameters opus_parameters = MakeMinimalOpusParameters(); |
| 504 EXPECT_TRUE(audio_receiver->Receive(opus_parameters).ok()); |
| 505 EXPECT_EQ(opus_parameters, audio_receiver->GetParameters()); |
| 506 |
| 507 RtpParameters isac_parameters = MakeMinimalIsacParameters(); |
| 508 // Sanity check that num_channels actually is left unset. |
| 509 ASSERT_FALSE(isac_parameters.codecs[0].num_channels); |
| 510 EXPECT_TRUE(audio_receiver->Receive(isac_parameters).ok()); |
| 511 // Should be filled with a default "num channels" of 1. |
| 512 // TODO(deadbeef): This should actually default to 2 for some codecs. Update |
| 513 // this test once that's implemented. |
| 514 isac_parameters.codecs[0].num_channels.emplace(1); |
| 515 EXPECT_EQ(isac_parameters, audio_receiver->GetParameters()); |
| 516 |
| 517 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 518 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 519 auto video_receiver = video_receiver_result.MoveValue(); |
| 520 |
| 521 RtpParameters vp8_parameters = MakeMinimalVp8Parameters(); |
| 522 // Sanity check that clock_rate actually is left unset. |
| 523 EXPECT_TRUE(video_receiver->Receive(vp8_parameters).ok()); |
| 524 // Should be filled with a default clock rate of 90000. |
| 525 vp8_parameters.codecs[0].clock_rate.emplace(90000); |
| 526 EXPECT_EQ(vp8_parameters, video_receiver->GetParameters()); |
| 527 |
| 528 RtpParameters vp9_parameters = MakeMinimalVp9Parameters(); |
| 529 // Sanity check that clock_rate actually is left unset. |
| 530 EXPECT_TRUE(video_receiver->Receive(vp9_parameters).ok()); |
| 531 // Should be filled with a default clock rate of 90000. |
| 532 vp9_parameters.codecs[0].clock_rate.emplace(90000); |
| 533 EXPECT_EQ(vp9_parameters, video_receiver->GetParameters()); |
| 534 } |
| 535 |
| 536 TEST_F(OrtcRtpReceiverTest, GetKind) { |
| 537 auto audio_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 538 cricket::MEDIA_TYPE_AUDIO, rtp_transport_.get()); |
| 539 auto video_receiver_result = ortc_factory_->CreateRtpReceiver( |
| 540 cricket::MEDIA_TYPE_VIDEO, rtp_transport_.get()); |
| 541 auto audio_receiver = audio_receiver_result.MoveValue(); |
| 542 auto video_receiver = video_receiver_result.MoveValue(); |
| 543 EXPECT_EQ(cricket::MEDIA_TYPE_AUDIO, audio_receiver->GetKind()); |
| 544 EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, video_receiver->GetKind()); |
| 545 } |
| 546 |
| 547 } // namespace webrtc |
OLD | NEW |