OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 | 11 |
12 /* | 12 /* |
13 * This file includes unit tests for the RTCPSender. | 13 * This file includes unit tests for the RTCPSender. |
14 */ | 14 */ |
15 | 15 |
16 #include "testing/gmock/include/gmock/gmock.h" | 16 #include "testing/gmock/include/gmock/gmock.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 17 #include "testing/gtest/include/gtest/gtest.h" |
18 | 18 |
19 #include "webrtc/common_types.h" | 19 #include "webrtc/common_types.h" |
20 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra
te_observer.h" | |
21 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_singl
e_stream.h" | |
22 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" | |
23 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h" | |
24 #include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h" | |
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" | |
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" | 20 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" |
27 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h" | |
28 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" | 21 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" |
29 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" | 22 #include "webrtc/test/rtcp_packet_parser.h" |
| 23 |
| 24 using ::testing::ElementsAre; |
30 | 25 |
31 namespace webrtc { | 26 namespace webrtc { |
32 | 27 |
33 TEST(NACKStringBuilderTest, TestCase1) { | 28 TEST(NACKStringBuilderTest, TestCase1) { |
34 NACKStringBuilder builder; | 29 NACKStringBuilder builder; |
35 builder.PushNACK(5); | 30 builder.PushNACK(5); |
36 builder.PushNACK(7); | 31 builder.PushNACK(7); |
37 builder.PushNACK(9); | 32 builder.PushNACK(9); |
38 builder.PushNACK(10); | 33 builder.PushNACK(10); |
39 builder.PushNACK(11); | 34 builder.PushNACK(11); |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
178 } | 173 } |
179 | 174 |
180 TEST(NACKStringBuilderTest, TestCase13) { | 175 TEST(NACKStringBuilderTest, TestCase13) { |
181 NACKStringBuilder builder; | 176 NACKStringBuilder builder; |
182 builder.PushNACK(5); | 177 builder.PushNACK(5); |
183 builder.PushNACK(6); | 178 builder.PushNACK(6); |
184 builder.PushNACK(9); | 179 builder.PushNACK(9); |
185 EXPECT_EQ(std::string("5-6,9"), builder.GetResult()); | 180 EXPECT_EQ(std::string("5-6,9"), builder.GetResult()); |
186 } | 181 } |
187 | 182 |
188 void CreateRtpPacket(const bool marker_bit, const uint8_t payload_type, | 183 class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver { |
189 const uint16_t seq_num, const uint32_t timestamp, | 184 public: |
190 const uint32_t ssrc, uint8_t* array, | 185 RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {} |
191 size_t* cur_pos) { | 186 virtual ~RtcpPacketTypeCounterObserverImpl() {} |
192 ASSERT_LE(payload_type, 127); | 187 void RtcpPacketTypesCounterUpdated( |
193 array[(*cur_pos)++] = 0x80; | 188 uint32_t ssrc, |
194 array[(*cur_pos)++] = payload_type | (marker_bit ? 0x80 : 0); | 189 const RtcpPacketTypeCounter& packet_counter) override { |
195 array[(*cur_pos)++] = seq_num >> 8; | 190 ssrc_ = ssrc; |
196 array[(*cur_pos)++] = seq_num & 0xFF; | 191 counter_ = packet_counter; |
197 array[(*cur_pos)++] = timestamp >> 24; | 192 } |
198 array[(*cur_pos)++] = (timestamp >> 16) & 0xFF; | 193 uint32_t ssrc_; |
199 array[(*cur_pos)++] = (timestamp >> 8) & 0xFF; | 194 RtcpPacketTypeCounter counter_; |
200 array[(*cur_pos)++] = timestamp & 0xFF; | 195 }; |
201 array[(*cur_pos)++] = ssrc >> 24; | |
202 array[(*cur_pos)++] = (ssrc >> 16) & 0xFF; | |
203 array[(*cur_pos)++] = (ssrc >> 8) & 0xFF; | |
204 array[(*cur_pos)++] = ssrc & 0xFF; | |
205 // VP8 payload header | |
206 array[(*cur_pos)++] = 0x90; // X bit = 1 | |
207 array[(*cur_pos)++] = 0x20; // T bit = 1 | |
208 array[(*cur_pos)++] = 0x00; // TID = 0 | |
209 array[(*cur_pos)++] = 0x00; // Key frame | |
210 array[(*cur_pos)++] = 0x00; | |
211 array[(*cur_pos)++] = 0x00; | |
212 array[(*cur_pos)++] = 0x9d; | |
213 array[(*cur_pos)++] = 0x01; | |
214 array[(*cur_pos)++] = 0x2a; | |
215 array[(*cur_pos)++] = 128; | |
216 array[(*cur_pos)++] = 0; | |
217 array[(*cur_pos)++] = 96; | |
218 array[(*cur_pos)++] = 0; | |
219 } | |
220 | 196 |
221 class TestTransport : public Transport, | 197 class TestTransport : public Transport, |
222 public NullRtpData { | 198 public NullRtpData { |
223 public: | 199 public: |
224 TestTransport() | 200 TestTransport() {} |
225 : rtcp_receiver_(NULL) { | 201 |
226 } | |
227 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { | |
228 rtcp_receiver_ = rtcp_receiver; | |
229 } | |
230 int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override { | 202 int SendPacket(int /*ch*/, const void* /*data*/, size_t /*len*/) override { |
231 return -1; | 203 return -1; |
232 } | 204 } |
233 | 205 int SendRTCPPacket(int /*ch*/, const void* data, size_t len) override { |
234 int SendRTCPPacket(int /*ch*/, | 206 parser_.Parse(static_cast<const uint8_t*>(data), len); |
235 const void* packet, | 207 return static_cast<int>(len); |
236 size_t packet_len) override { | 208 } |
237 RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet, | 209 int OnReceivedPayloadData(const uint8_t* payload_data, |
238 packet_len, | 210 const size_t payload_size, |
239 true); // Allow non-compound RTCP | 211 const WebRtcRTPHeader* rtp_header) override { |
240 | |
241 EXPECT_TRUE(rtcpParser.IsValid()); | |
242 RTCPHelp::RTCPPacketInformation rtcpPacketInformation; | |
243 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation, | |
244 &rtcpParser)); | |
245 rtcp_packet_info_.rtcpPacketTypeFlags = | |
246 rtcpPacketInformation.rtcpPacketTypeFlags; | |
247 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC; | |
248 rtcp_packet_info_.applicationSubType = | |
249 rtcpPacketInformation.applicationSubType; | |
250 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName; | |
251 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks; | |
252 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; | |
253 rtcp_packet_info_.interArrivalJitter = | |
254 rtcpPacketInformation.interArrivalJitter; | |
255 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; | |
256 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; | |
257 rtcp_packet_info_.receiverEstimatedMaxBitrate = | |
258 rtcpPacketInformation.receiverEstimatedMaxBitrate; | |
259 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; | |
260 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; | |
261 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; | |
262 | |
263 return static_cast<int>(packet_len); | |
264 } | |
265 | |
266 int OnReceivedPayloadData(const uint8_t* payloadData, | |
267 const size_t payloadSize, | |
268 const WebRtcRTPHeader* rtpHeader) override { | |
269 return 0; | 212 return 0; |
270 } | 213 } |
271 RTCPReceiver* rtcp_receiver_; | 214 test::RtcpPacketParser parser_; |
272 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; | |
273 }; | 215 }; |
274 | 216 |
275 namespace { | 217 namespace { |
276 static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000; | 218 static const uint32_t kSenderSsrc = 0x11111111; |
277 static const int kMaxPacketLength = 1500; | 219 static const uint32_t kRemoteSsrc = 0x22222222; |
278 static const uint32_t kMainSsrc = 0x11111111; | |
279 } | 220 } |
280 | 221 |
281 class RtcpSenderTest : public ::testing::Test { | 222 class RtcpSenderTest : public ::testing::Test { |
282 protected: | 223 protected: |
283 RtcpSenderTest() | 224 RtcpSenderTest() |
284 : over_use_detector_options_(), | 225 : clock_(1335900000), |
285 clock_(1335900000), | |
286 rtp_payload_registry_( | |
287 new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))), | |
288 remote_bitrate_observer_(), | |
289 remote_bitrate_estimator_(new RemoteBitrateEstimatorSingleStream( | |
290 &remote_bitrate_observer_, | |
291 &clock_, | |
292 kRemoteBitrateEstimatorMinBitrateBps)), | |
293 receive_statistics_(ReceiveStatistics::Create(&clock_)) { | 226 receive_statistics_(ReceiveStatistics::Create(&clock_)) { |
294 test_transport_ = new TestTransport(); | |
295 | |
296 RtpRtcp::Configuration configuration; | 227 RtpRtcp::Configuration configuration; |
297 configuration.id = 0; | 228 configuration.id = 0; |
298 configuration.audio = false; | 229 configuration.audio = false; |
299 configuration.clock = &clock_; | 230 configuration.clock = &clock_; |
300 configuration.outgoing_transport = test_transport_; | 231 configuration.outgoing_transport = &test_transport_; |
301 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); | 232 |
302 | 233 rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration)); |
303 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); | 234 rtcp_sender_.reset(new RTCPSender(configuration.id, false, &clock_, |
304 rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver( | 235 receive_statistics_.get(), nullptr)); |
305 configuration.id, &clock_, test_transport_, NULL, | 236 rtcp_sender_->SetSSRC(kSenderSsrc); |
306 rtp_payload_registry_.get())); | 237 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
307 rtcp_sender_ = | 238 EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(&test_transport_)); |
308 new RTCPSender(configuration.id, false, &clock_, | 239 } |
309 receive_statistics_.get(), NULL); | 240 |
310 rtcp_sender_->SetSSRC(kMainSsrc); | 241 void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) { |
311 rtcp_receiver_ = | 242 RTPHeader header; |
312 new RTCPReceiver(configuration.id, &clock_, false, NULL, NULL, NULL, | 243 header.ssrc = remote_ssrc; |
313 rtp_rtcp_impl_); | 244 header.sequenceNumber = seq_num; |
314 rtcp_receiver_->SetRemoteSSRC(kMainSsrc); | 245 header.timestamp = 12345; |
315 | 246 header.headerLength = 12; |
316 std::set<uint32_t> registered_ssrcs; | 247 size_t kPacketLength = 100; |
317 registered_ssrcs.insert(kMainSsrc); | 248 receive_statistics_->IncomingPacket(header, kPacketLength, false); |
318 rtcp_receiver_->SetSsrcs(kMainSsrc, registered_ssrcs); | 249 } |
319 test_transport_->SetRTCPReceiver(rtcp_receiver_); | 250 |
320 // Initialize | 251 test::RtcpPacketParser* parser() { return &test_transport_.parser_; } |
321 EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_)); | 252 |
322 } | 253 RTCPSender::FeedbackState feedback_state() { |
323 | 254 return rtp_rtcp_impl_->GetFeedbackState(); |
324 ~RtcpSenderTest() { | 255 } |
325 delete rtcp_sender_; | 256 |
326 delete rtcp_receiver_; | |
327 delete rtp_rtcp_impl_; | |
328 delete test_transport_; | |
329 } | |
330 | |
331 // Helper function: Incoming RTCP has a specific packet type. | |
332 bool gotPacketType(RTCPPacketType packet_type) { | |
333 return ((test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags) & | |
334 packet_type) != 0U; | |
335 } | |
336 | |
337 OverUseDetectorOptions over_use_detector_options_; | |
338 SimulatedClock clock_; | 257 SimulatedClock clock_; |
339 rtc::scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_; | 258 TestTransport test_transport_; |
340 rtc::scoped_ptr<RtpReceiver> rtp_receiver_; | |
341 ModuleRtpRtcpImpl* rtp_rtcp_impl_; | |
342 RTCPSender* rtcp_sender_; | |
343 RTCPReceiver* rtcp_receiver_; | |
344 TestTransport* test_transport_; | |
345 MockRemoteBitrateObserver remote_bitrate_observer_; | |
346 rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; | |
347 rtc::scoped_ptr<ReceiveStatistics> receive_statistics_; | 259 rtc::scoped_ptr<ReceiveStatistics> receive_statistics_; |
348 | 260 rtc::scoped_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_; |
349 uint8_t packet_[kMaxPacketLength]; | 261 rtc::scoped_ptr<RTCPSender> rtcp_sender_; |
350 }; | 262 }; |
351 | 263 |
352 TEST_F(RtcpSenderTest, RtcpOff) { | 264 TEST_F(RtcpSenderTest, SetRtcpStatus) { |
| 265 EXPECT_EQ(kRtcpOff, rtcp_sender_->Status()); |
| 266 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 267 EXPECT_EQ(kRtcpNonCompound, rtcp_sender_->Status()); |
| 268 } |
| 269 |
| 270 TEST_F(RtcpSenderTest, SetSendingStatus) { |
| 271 EXPECT_FALSE(rtcp_sender_->Sending()); |
| 272 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 273 EXPECT_TRUE(rtcp_sender_->Sending()); |
| 274 } |
| 275 |
| 276 TEST_F(RtcpSenderTest, NoPacketSentIfOff) { |
353 rtcp_sender_->SetRTCPStatus(kRtcpOff); | 277 rtcp_sender_->SetRTCPStatus(kRtcpOff); |
| 278 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
| 279 } |
| 280 |
| 281 TEST_F(RtcpSenderTest, SendSr) { |
| 282 const uint32_t kPacketCount = 0x12345; |
| 283 const uint32_t kOctetCount = 0x23456; |
| 284 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
354 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 285 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
355 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); | 286 feedback_state.packets_sent = kPacketCount; |
356 } | 287 feedback_state.media_bytes_sent = kOctetCount; |
357 | 288 uint32_t ntp_secs; |
358 TEST_F(RtcpSenderTest, TestCompound) { | 289 uint32_t ntp_frac; |
359 const bool marker_bit = false; | 290 clock_.CurrentNtp(ntp_secs, ntp_frac); |
360 const uint8_t payload_type = 100; | 291 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); |
361 const uint16_t seq_num = 11111; | 292 EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
362 const uint32_t timestamp = 1234567; | 293 EXPECT_EQ(kSenderSsrc, parser()->sender_report()->Ssrc()); |
363 size_t packet_length = 0; | 294 EXPECT_EQ(ntp_secs, parser()->sender_report()->NtpSec()); |
364 CreateRtpPacket(marker_bit, payload_type, seq_num, timestamp, kMainSsrc, | 295 EXPECT_EQ(ntp_frac, parser()->sender_report()->NtpFrac()); |
365 packet_, &packet_length); | 296 EXPECT_EQ(kPacketCount, parser()->sender_report()->PacketCount()); |
366 EXPECT_EQ(25u, packet_length); | 297 EXPECT_EQ(kOctetCount, parser()->sender_report()->OctetCount()); |
367 | 298 EXPECT_EQ(0, parser()->report_block()->num_packets()); |
368 VideoCodec codec_inst; | 299 } |
369 strncpy(codec_inst.plName, "VP8", webrtc::kPayloadNameSize - 1); | 300 |
370 codec_inst.codecType = webrtc::kVideoCodecVP8; | 301 TEST_F(RtcpSenderTest, SendRr) { |
371 codec_inst.plType = payload_type; | 302 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
372 EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec_inst.plName, | 303 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
373 codec_inst.plType, | 304 EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
374 90000, | 305 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc()); |
375 0, | 306 EXPECT_EQ(0, parser()->report_block()->num_packets()); |
376 codec_inst.maxBitrate)); | 307 } |
377 | 308 |
378 // Make sure RTP packet has been received. | 309 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) { |
379 rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); | 310 const uint16_t kSeqNum = 11111; |
380 RTPHeader header; | 311 InsertIncomingPacket(kRemoteSsrc, kSeqNum); |
381 EXPECT_TRUE(parser->Parse(packet_, packet_length, &header)); | 312 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
382 PayloadUnion payload_specific; | 313 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
383 EXPECT_TRUE(rtp_payload_registry_->GetPayloadSpecifics(header.payloadType, | 314 EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
384 &payload_specific)); | 315 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc()); |
385 receive_statistics_->IncomingPacket(header, packet_length, false); | 316 EXPECT_EQ(1, parser()->report_block()->num_packets()); |
386 EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(header, packet_, packet_length, | 317 EXPECT_EQ(kRemoteSsrc, parser()->report_block()->Ssrc()); |
387 payload_specific, true)); | 318 EXPECT_EQ(0U, parser()->report_block()->FractionLost()); |
388 | 319 EXPECT_EQ(0U, parser()->report_block()->CumPacketLost()); |
389 rtcp_sender_->SetCNAME("Foo"); | 320 EXPECT_EQ(kSeqNum, parser()->report_block()->ExtHighestSeqNum()); |
390 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 321 } |
| 322 |
| 323 TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) { |
| 324 const uint16_t kSeqNum = 11111; |
| 325 InsertIncomingPacket(kRemoteSsrc, kSeqNum); |
| 326 InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1); |
| 327 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 328 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
| 329 EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
| 330 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->Ssrc()); |
| 331 EXPECT_EQ(2, parser()->report_block()->num_packets()); |
| 332 EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc)); |
| 333 EXPECT_EQ(1, parser()->report_blocks_per_ssrc(kRemoteSsrc + 1)); |
| 334 } |
| 335 |
| 336 TEST_F(RtcpSenderTest, SendSdes) { |
| 337 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 338 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host")); |
| 339 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes)); |
| 340 EXPECT_EQ(1, parser()->sdes()->num_packets()); |
| 341 EXPECT_EQ(1, parser()->sdes_chunk()->num_packets()); |
| 342 EXPECT_EQ(kSenderSsrc, parser()->sdes_chunk()->Ssrc()); |
| 343 EXPECT_EQ("alice@host", parser()->sdes_chunk()->Cname()); |
| 344 } |
| 345 |
| 346 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) { |
| 347 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 348 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host")); |
| 349 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 350 EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
| 351 EXPECT_EQ(1, parser()->sdes()->num_packets()); |
| 352 EXPECT_EQ(1, parser()->sdes_chunk()->num_packets()); |
| 353 } |
| 354 |
| 355 TEST_F(RtcpSenderTest, SendBye) { |
| 356 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 357 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye)); |
| 358 EXPECT_EQ(1, parser()->bye()->num_packets()); |
| 359 EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc()); |
| 360 } |
| 361 |
| 362 TEST_F(RtcpSenderTest, StopSendingTriggersBye) { |
| 363 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 364 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 365 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
| 366 EXPECT_EQ(1, parser()->bye()->num_packets()); |
| 367 EXPECT_EQ(kSenderSsrc, parser()->bye()->Ssrc()); |
| 368 } |
| 369 |
| 370 TEST_F(RtcpSenderTest, SendApp) { |
| 371 const uint8_t kSubType = 30; |
| 372 uint32_t name = 'n' << 24; |
| 373 name += 'a' << 16; |
| 374 name += 'm' << 8; |
| 375 name += 'e'; |
| 376 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; |
| 377 const uint16_t kDataLength = sizeof(kData) / sizeof(kData[0]); |
| 378 EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData, |
| 379 kDataLength)); |
| 380 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 381 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp)); |
| 382 EXPECT_EQ(1, parser()->app()->num_packets()); |
| 383 EXPECT_EQ(kSubType, parser()->app()->SubType()); |
| 384 EXPECT_EQ(name, parser()->app()->Name()); |
| 385 EXPECT_EQ(1, parser()->app_item()->num_packets()); |
| 386 EXPECT_EQ(kDataLength, parser()->app_item()->DataLength()); |
| 387 EXPECT_EQ(0, strncmp(reinterpret_cast<const char*>(kData), |
| 388 reinterpret_cast<const char*>(parser()->app_item()->Data()), |
| 389 parser()->app_item()->DataLength())); |
| 390 } |
| 391 |
| 392 TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) { |
| 393 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'}; |
| 394 const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]); |
| 395 EXPECT_EQ(-1, rtcp_sender_->SetApplicationSpecificData( |
| 396 0, 0, kData, kInvalidDataLength)); // Should by multiple of 4. |
| 397 } |
| 398 |
| 399 TEST_F(RtcpSenderTest, SendFirNonRepeat) { |
| 400 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 401 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir)); |
| 402 EXPECT_EQ(1, parser()->fir()->num_packets()); |
| 403 EXPECT_EQ(kSenderSsrc, parser()->fir()->Ssrc()); |
| 404 EXPECT_EQ(1, parser()->fir_item()->num_packets()); |
| 405 EXPECT_EQ(kRemoteSsrc, parser()->fir_item()->Ssrc()); |
| 406 uint8_t seq = parser()->fir_item()->SeqNum(); |
| 407 // Sends non-repeat FIR as default. |
| 408 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir)); |
| 409 EXPECT_EQ(2, parser()->fir()->num_packets()); |
| 410 EXPECT_EQ(2, parser()->fir_item()->num_packets()); |
| 411 EXPECT_EQ(seq + 1, parser()->fir_item()->SeqNum()); |
| 412 } |
| 413 |
| 414 TEST_F(RtcpSenderTest, SendFirRepeat) { |
| 415 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 416 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir)); |
| 417 EXPECT_EQ(1, parser()->fir()->num_packets()); |
| 418 EXPECT_EQ(1, parser()->fir_item()->num_packets()); |
| 419 uint8_t seq = parser()->fir_item()->SeqNum(); |
| 420 const bool kRepeat = true; |
| 421 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir, 0, nullptr, |
| 422 kRepeat)); |
| 423 EXPECT_EQ(2, parser()->fir()->num_packets()); |
| 424 EXPECT_EQ(2, parser()->fir_item()->num_packets()); |
| 425 EXPECT_EQ(seq, parser()->fir_item()->SeqNum()); |
| 426 } |
| 427 |
| 428 TEST_F(RtcpSenderTest, SendPli) { |
| 429 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 430 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 431 EXPECT_EQ(1, parser()->pli()->num_packets()); |
| 432 EXPECT_EQ(kSenderSsrc, parser()->pli()->Ssrc()); |
| 433 EXPECT_EQ(kRemoteSsrc, parser()->pli()->MediaSsrc()); |
| 434 } |
| 435 |
| 436 TEST_F(RtcpSenderTest, SendRpsi) { |
| 437 const uint64_t kPictureId = 0x41; |
| 438 const int8_t kPayloadType = 100; |
| 439 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
391 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 440 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
392 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr)); | 441 feedback_state.send_payload_type = kPayloadType; |
393 | 442 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRpsi, 0, nullptr, |
394 // Sdes packet should be received, along with report blocks. | 443 false, kPictureId)); |
395 ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | 444 EXPECT_EQ(kPayloadType, parser()->rpsi()->PayloadType()); |
396 kRtcpSdes); | 445 EXPECT_EQ(kPictureId, parser()->rpsi()->PictureId()); |
397 EXPECT_GT(test_transport_->rtcp_packet_info_.report_blocks.size(), 0u); | 446 } |
398 } | 447 |
399 | 448 TEST_F(RtcpSenderTest, SendSli) { |
400 TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) { | 449 const uint16_t kFirstMb = 0; |
401 rtcp_sender_->SetCNAME("Foo"); | 450 const uint16_t kNumberOfMb = 0x1FFF; |
| 451 const uint8_t kPictureId = 60; |
| 452 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 453 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSli, 0, nullptr, |
| 454 false, kPictureId)); |
| 455 EXPECT_EQ(1, parser()->sli()->num_packets()); |
| 456 EXPECT_EQ(kSenderSsrc, parser()->sli()->Ssrc()); |
| 457 EXPECT_EQ(kRemoteSsrc, parser()->sli()->MediaSsrc()); |
| 458 EXPECT_EQ(1, parser()->sli_item()->num_packets()); |
| 459 EXPECT_EQ(kFirstMb, parser()->sli_item()->FirstMb()); |
| 460 EXPECT_EQ(kNumberOfMb, parser()->sli_item()->NumberOfMb()); |
| 461 EXPECT_EQ(kPictureId, parser()->sli_item()->PictureId()); |
| 462 } |
| 463 |
| 464 TEST_F(RtcpSenderTest, SendNack) { |
| 465 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 466 const uint16_t kList[] = {0, 1, 16}; |
| 467 const int32_t kListLength = sizeof(kList) / sizeof(kList[0]); |
| 468 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack, kListLength, |
| 469 kList)); |
| 470 EXPECT_EQ(1, parser()->nack()->num_packets()); |
| 471 EXPECT_EQ(kSenderSsrc, parser()->nack()->Ssrc()); |
| 472 EXPECT_EQ(kRemoteSsrc, parser()->nack()->MediaSsrc()); |
| 473 EXPECT_EQ(1, parser()->nack_item()->num_packets()); |
| 474 EXPECT_THAT(parser()->nack_item()->last_nack_list(), ElementsAre(0, 1, 16)); |
| 475 } |
| 476 |
| 477 TEST_F(RtcpSenderTest, SendRemb) { |
| 478 const int kBitrate = 261011; |
| 479 std::vector<uint32_t> ssrcs; |
| 480 ssrcs.push_back(kRemoteSsrc); |
| 481 ssrcs.push_back(kRemoteSsrc + 1); |
| 482 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 483 rtcp_sender_->SetREMBData(kBitrate, ssrcs); |
| 484 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb)); |
| 485 EXPECT_EQ(1, parser()->psfb_app()->num_packets()); |
| 486 EXPECT_EQ(kSenderSsrc, parser()->psfb_app()->Ssrc()); |
| 487 EXPECT_EQ(1, parser()->remb_item()->num_packets()); |
| 488 EXPECT_EQ(kBitrate, parser()->remb_item()->last_bitrate_bps()); |
| 489 EXPECT_THAT(parser()->remb_item()->last_ssrc_list(), |
| 490 ElementsAre(kRemoteSsrc, kRemoteSsrc + 1)); |
| 491 } |
| 492 |
| 493 TEST_F(RtcpSenderTest, RembIncludedInCompoundPacketIfEnabled) { |
| 494 const int kBitrate = 261011; |
| 495 std::vector<uint32_t> ssrcs; |
| 496 ssrcs.push_back(kRemoteSsrc); |
| 497 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 498 rtcp_sender_->SetREMBStatus(true); |
| 499 EXPECT_TRUE(rtcp_sender_->REMB()); |
| 500 rtcp_sender_->SetREMBData(kBitrate, ssrcs); |
| 501 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 502 EXPECT_EQ(1, parser()->psfb_app()->num_packets()); |
| 503 EXPECT_EQ(1, parser()->remb_item()->num_packets()); |
| 504 // REMB should be included in each compound packet. |
| 505 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 506 EXPECT_EQ(2, parser()->psfb_app()->num_packets()); |
| 507 EXPECT_EQ(2, parser()->remb_item()->num_packets()); |
| 508 } |
| 509 |
| 510 TEST_F(RtcpSenderTest, RembNotIncludedInCompoundPacketIfNotEnabled) { |
| 511 const int kBitrate = 261011; |
| 512 std::vector<uint32_t> ssrcs; |
| 513 ssrcs.push_back(kRemoteSsrc); |
| 514 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 515 rtcp_sender_->SetREMBData(kBitrate, ssrcs); |
| 516 EXPECT_FALSE(rtcp_sender_->REMB()); |
| 517 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 518 EXPECT_EQ(0, parser()->psfb_app()->num_packets()); |
| 519 } |
| 520 |
| 521 TEST_F(RtcpSenderTest, SendXrWithVoipMetric) { |
| 522 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 523 RTCPVoIPMetric metric; |
| 524 metric.lossRate = 1; |
| 525 metric.discardRate = 2; |
| 526 metric.burstDensity = 3; |
| 527 metric.gapDensity = 4; |
| 528 metric.burstDuration = 0x1111; |
| 529 metric.gapDuration = 0x2222; |
| 530 metric.roundTripDelay = 0x3333; |
| 531 metric.endSystemDelay = 0x4444; |
| 532 metric.signalLevel = 5; |
| 533 metric.noiseLevel = 6; |
| 534 metric.RERL = 7; |
| 535 metric.Gmin = 8; |
| 536 metric.Rfactor = 9; |
| 537 metric.extRfactor = 10; |
| 538 metric.MOSLQ = 11; |
| 539 metric.MOSCQ = 12; |
| 540 metric.RXconfig = 13; |
| 541 metric.JBnominal = 0x5555; |
| 542 metric.JBmax = 0x6666; |
| 543 metric.JBabsMax = 0x7777; |
| 544 EXPECT_EQ(0, rtcp_sender_->SetRTCPVoIPMetrics(&metric)); |
| 545 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpXrVoipMetric)); |
| 546 EXPECT_EQ(1, parser()->xr_header()->num_packets()); |
| 547 EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc()); |
| 548 EXPECT_EQ(1, parser()->voip_metric()->num_packets()); |
| 549 EXPECT_EQ(kRemoteSsrc, parser()->voip_metric()->Ssrc()); |
| 550 EXPECT_EQ(metric.lossRate, parser()->voip_metric()->LossRate()); |
| 551 EXPECT_EQ(metric.discardRate, parser()->voip_metric()->DiscardRate()); |
| 552 EXPECT_EQ(metric.burstDensity, parser()->voip_metric()->BurstDensity()); |
| 553 EXPECT_EQ(metric.gapDensity, parser()->voip_metric()->GapDensity()); |
| 554 EXPECT_EQ(metric.burstDuration, parser()->voip_metric()->BurstDuration()); |
| 555 EXPECT_EQ(metric.gapDuration, parser()->voip_metric()->GapDuration()); |
| 556 EXPECT_EQ(metric.roundTripDelay, parser()->voip_metric()->RoundTripDelay()); |
| 557 EXPECT_EQ(metric.endSystemDelay, parser()->voip_metric()->EndSystemDelay()); |
| 558 EXPECT_EQ(metric.signalLevel, parser()->voip_metric()->SignalLevel()); |
| 559 EXPECT_EQ(metric.noiseLevel, parser()->voip_metric()->NoiseLevel()); |
| 560 EXPECT_EQ(metric.RERL, parser()->voip_metric()->Rerl()); |
| 561 EXPECT_EQ(metric.Gmin, parser()->voip_metric()->Gmin()); |
| 562 EXPECT_EQ(metric.Rfactor, parser()->voip_metric()->Rfactor()); |
| 563 EXPECT_EQ(metric.extRfactor, parser()->voip_metric()->ExtRfactor()); |
| 564 EXPECT_EQ(metric.MOSLQ, parser()->voip_metric()->MosLq()); |
| 565 EXPECT_EQ(metric.MOSCQ, parser()->voip_metric()->MosCq()); |
| 566 EXPECT_EQ(metric.RXconfig, parser()->voip_metric()->RxConfig()); |
| 567 EXPECT_EQ(metric.JBnominal, parser()->voip_metric()->JbNominal()); |
| 568 EXPECT_EQ(metric.JBmax, parser()->voip_metric()->JbMax()); |
| 569 EXPECT_EQ(metric.JBabsMax, parser()->voip_metric()->JbAbsMax()); |
| 570 } |
| 571 |
| 572 TEST_F(RtcpSenderTest, SendXrWithDlrr) { |
402 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 573 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
403 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 574 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
404 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr)); | 575 feedback_state.has_last_xr_rr = true; |
405 | 576 RtcpReceiveTimeInfo last_xr_rr; |
406 // Sdes should be received, but no report blocks. | 577 last_xr_rr.sourceSSRC = 0x11111111; |
407 ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | 578 last_xr_rr.lastRR = 0x22222222; |
408 kRtcpSdes); | 579 last_xr_rr.delaySinceLastRR = 0x33333333; |
409 EXPECT_EQ(0u, test_transport_->rtcp_packet_info_.report_blocks.size()); | 580 feedback_state.last_xr_rr = last_xr_rr; |
410 } | 581 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); |
411 | 582 EXPECT_EQ(1, parser()->xr_header()->num_packets()); |
412 TEST_F(RtcpSenderTest, TestXrReceiverReferenceTime) { | 583 EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc()); |
| 584 EXPECT_EQ(1, parser()->dlrr()->num_packets()); |
| 585 EXPECT_EQ(1, parser()->dlrr_items()->num_packets()); |
| 586 EXPECT_EQ(last_xr_rr.sourceSSRC, parser()->dlrr_items()->Ssrc(0)); |
| 587 EXPECT_EQ(last_xr_rr.lastRR, parser()->dlrr_items()->LastRr(0)); |
| 588 EXPECT_EQ(last_xr_rr.delaySinceLastRR, |
| 589 parser()->dlrr_items()->DelayLastRr(0)); |
| 590 } |
| 591 |
| 592 TEST_F(RtcpSenderTest, SendXrWithRrtr) { |
| 593 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 594 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
| 595 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
| 596 uint32_t ntp_secs; |
| 597 uint32_t ntp_frac; |
| 598 clock_.CurrentNtp(ntp_secs, ntp_frac); |
| 599 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 600 EXPECT_EQ(1, parser()->xr_header()->num_packets()); |
| 601 EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc()); |
| 602 EXPECT_EQ(0, parser()->dlrr()->num_packets()); |
| 603 EXPECT_EQ(1, parser()->rrtr()->num_packets()); |
| 604 EXPECT_EQ(ntp_secs, parser()->rrtr()->NtpSec()); |
| 605 EXPECT_EQ(ntp_frac, parser()->rrtr()->NtpFrac()); |
| 606 } |
| 607 |
| 608 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) { |
| 609 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 610 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 611 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
| 612 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 613 EXPECT_EQ(0, parser()->xr_header()->num_packets()); |
| 614 EXPECT_EQ(0, parser()->rrtr()->num_packets()); |
| 615 } |
| 616 |
| 617 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) { |
| 618 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 619 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
| 620 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false); |
| 621 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 622 EXPECT_EQ(0, parser()->xr_header()->num_packets()); |
| 623 EXPECT_EQ(0, parser()->rrtr()->num_packets()); |
| 624 } |
| 625 |
| 626 TEST_F(RtcpSenderTest, TestSendTimeOfXrRrtr) { |
413 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 627 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
414 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 628 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
415 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); | 629 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); |
416 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); | |
417 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); | |
418 | |
419 EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | |
420 kRtcpXrReceiverReferenceTime); | |
421 } | |
422 | |
423 TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfSending) { | |
424 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
425 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | |
426 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, true)); | |
427 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); | |
428 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); | |
429 | |
430 EXPECT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | |
431 kRtcpXrReceiverReferenceTime); | |
432 } | |
433 | |
434 TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfNotEnabled) { | |
435 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
436 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | |
437 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); | |
438 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false); | |
439 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); | |
440 | |
441 EXPECT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | |
442 kRtcpXrReceiverReferenceTime); | |
443 } | |
444 | |
445 TEST_F(RtcpSenderTest, TestSendTimeOfXrRrReport) { | |
446 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
447 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | |
448 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); | |
449 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); | 630 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
450 uint32_t ntp_sec; | 631 uint32_t ntp_sec; |
451 uint32_t ntp_frac; | 632 uint32_t ntp_frac; |
452 clock_.CurrentNtp(ntp_sec, ntp_frac); | 633 clock_.CurrentNtp(ntp_sec, ntp_frac); |
453 uint32_t initial_mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); | 634 uint32_t initial_mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); |
454 | 635 |
455 // No packet sent. | 636 // No packet sent. |
456 int64_t time_ms; | 637 int64_t time_ms; |
457 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); | 638 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); |
458 | 639 |
459 // Send XR RR packets. | 640 // Send XR RR packets. |
460 for (int i = 0; i <= RTCP_NUMBER_OF_SR; ++i) { | 641 for (int i = 0; i <= RTCP_NUMBER_OF_SR; ++i) { |
461 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); | 642 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); |
462 EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | 643 EXPECT_EQ(i + 1, test_transport_.parser_.rrtr()->num_packets()); |
463 kRtcpXrReceiverReferenceTime); | |
464 | |
465 clock_.CurrentNtp(ntp_sec, ntp_frac); | 644 clock_.CurrentNtp(ntp_sec, ntp_frac); |
466 uint32_t mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); | 645 uint32_t mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); |
467 EXPECT_TRUE(rtcp_sender_->SendTimeOfXrRrReport(mid_ntp, &time_ms)); | 646 EXPECT_TRUE(rtcp_sender_->SendTimeOfXrRrReport(mid_ntp, &time_ms)); |
468 EXPECT_EQ(clock_.CurrentNtpInMilliseconds(), time_ms); | 647 EXPECT_EQ(clock_.CurrentNtpInMilliseconds(), time_ms); |
469 clock_.AdvanceTimeMilliseconds(1000); | 648 clock_.AdvanceTimeMilliseconds(1000); |
470 } | 649 } |
471 | |
472 // The first report should no longer be stored. | 650 // The first report should no longer be stored. |
473 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); | 651 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); |
474 } | 652 } |
475 | 653 |
| 654 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) { |
| 655 RtcpPacketTypeCounterObserverImpl observer; |
| 656 rtcp_sender_.reset( |
| 657 new RTCPSender(0, false, &clock_, receive_statistics_.get(), &observer)); |
| 658 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
| 659 EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(&test_transport_)); |
| 660 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 661 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 662 EXPECT_EQ(1, parser()->pli()->num_packets()); |
| 663 EXPECT_EQ(kRemoteSsrc, observer.ssrc_); |
| 664 EXPECT_EQ(1U, observer.counter_.pli_packets); |
| 665 EXPECT_EQ(clock_.TimeInMilliseconds(), |
| 666 observer.counter_.first_packet_time_ms); |
| 667 } |
| 668 |
| 669 TEST_F(RtcpSenderTest, SendTmmbr) { |
| 670 const unsigned int kBitrateBps = 312000; |
| 671 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); |
| 672 rtcp_sender_->SetTargetBitrate(kBitrateBps); |
| 673 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr)); |
| 674 EXPECT_EQ(1, parser()->tmmbr()->num_packets()); |
| 675 EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->Ssrc()); |
| 676 EXPECT_EQ(1, parser()->tmmbr_item()->num_packets()); |
| 677 EXPECT_EQ(kBitrateBps / 1000, parser()->tmmbr_item()->BitrateKbps()); |
| 678 // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero. |
| 679 } |
| 680 |
| 681 TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) { |
| 682 const unsigned int kBitrateBps = 312000; |
| 683 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 684 EXPECT_FALSE(rtcp_sender_->TMMBR()); |
| 685 rtcp_sender_->SetTMMBRStatus(true); |
| 686 EXPECT_TRUE(rtcp_sender_->TMMBR()); |
| 687 rtcp_sender_->SetTargetBitrate(kBitrateBps); |
| 688 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 689 EXPECT_EQ(1, parser()->tmmbr()->num_packets()); |
| 690 EXPECT_EQ(1, parser()->tmmbr_item()->num_packets()); |
| 691 // TMMBR should be included in each compound packet. |
| 692 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 693 EXPECT_EQ(2, parser()->tmmbr()->num_packets()); |
| 694 EXPECT_EQ(2, parser()->tmmbr_item()->num_packets()); |
| 695 |
| 696 rtcp_sender_->SetTMMBRStatus(false); |
| 697 EXPECT_FALSE(rtcp_sender_->TMMBR()); |
| 698 } |
| 699 |
| 700 TEST_F(RtcpSenderTest, SendTmmbn) { |
| 701 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
| 702 TMMBRSet bounding_set; |
| 703 bounding_set.VerifyAndAllocateSet(1); |
| 704 const uint32_t kBitrateKbps = 32768; |
| 705 const uint32_t kPacketOh = 40; |
| 706 const uint32_t kSourceSsrc = 12345; |
| 707 bounding_set.AddEntry(kBitrateKbps, kPacketOh, kSourceSsrc); |
| 708 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 0)); |
| 709 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
| 710 EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
| 711 EXPECT_EQ(1, parser()->tmmbn()->num_packets()); |
| 712 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc()); |
| 713 EXPECT_EQ(1, parser()->tmmbn_items()->num_packets()); |
| 714 EXPECT_EQ(kBitrateKbps, parser()->tmmbn_items()->BitrateKbps(0)); |
| 715 EXPECT_EQ(kPacketOh, parser()->tmmbn_items()->Overhead(0)); |
| 716 EXPECT_EQ(kSourceSsrc, parser()->tmmbn_items()->Ssrc(0)); |
| 717 } |
| 718 |
476 // This test is written to verify actual behaviour. It does not seem | 719 // This test is written to verify actual behaviour. It does not seem |
477 // to make much sense to send an empty TMMBN, since there is no place | 720 // to make much sense to send an empty TMMBN, since there is no place |
478 // to put an actual limit here. It's just information that no limit | 721 // to put an actual limit here. It's just information that no limit |
479 // is set, which is kind of the starting assumption. | 722 // is set, which is kind of the starting assumption. |
480 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one | 723 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one |
481 // situation where this caused confusion. | 724 // situation where this caused confusion. |
482 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { | 725 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { |
483 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 726 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
484 TMMBRSet bounding_set; | 727 TMMBRSet bounding_set; |
485 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); | 728 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); |
486 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | 729 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
487 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 730 EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
488 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); | 731 EXPECT_EQ(1, parser()->tmmbn()->num_packets()); |
489 // We now expect the packet to show up in the rtcp_packet_info_ of | 732 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc()); |
490 // test_transport_. | 733 EXPECT_EQ(0, parser()->tmmbn_items()->num_packets()); |
491 ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | |
492 EXPECT_TRUE(gotPacketType(kRtcpTmmbn)); | |
493 TMMBRSet* incoming_set = NULL; | |
494 bool owner = false; | |
495 // The BoundingSet function returns the number of members of the | |
496 // bounding set, and touches the incoming set only if there's > 1. | |
497 EXPECT_EQ(0, test_transport_->rtcp_receiver_->BoundingSet(owner, | |
498 incoming_set)); | |
499 } | 734 } |
500 | 735 |
501 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndValid) { | 736 TEST_F(RtcpSenderTest, SendCompoundPliRemb) { |
| 737 const int kBitrate = 261011; |
| 738 std::vector<uint32_t> ssrcs; |
| 739 ssrcs.push_back(kRemoteSsrc); |
502 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 740 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
503 TMMBRSet bounding_set; | 741 rtcp_sender_->SetREMBData(kBitrate, ssrcs); |
504 bounding_set.VerifyAndAllocateSet(1); | 742 std::set<RTCPPacketType> packet_types; |
505 const uint32_t kSourceSsrc = 12345; | 743 packet_types.insert(kRtcpRemb); |
506 bounding_set.AddEntry(32768, 0, kSourceSsrc); | 744 packet_types.insert(kRtcpPli); |
507 | 745 EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types)); |
508 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); | 746 EXPECT_EQ(1, parser()->remb_item()->num_packets()); |
509 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | 747 EXPECT_EQ(1, parser()->pli()->num_packets()); |
510 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | |
511 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); | |
512 // We now expect the packet to show up in the rtcp_packet_info_ of | |
513 // test_transport_. | |
514 ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | |
515 EXPECT_TRUE(gotPacketType(kRtcpTmmbn)); | |
516 TMMBRSet incoming_set; | |
517 bool owner = false; | |
518 // We expect 1 member of the incoming set. | |
519 EXPECT_EQ(1, test_transport_->rtcp_receiver_->BoundingSet(owner, | |
520 &incoming_set)); | |
521 EXPECT_EQ(kSourceSsrc, incoming_set.Ssrc(0)); | |
522 } | 748 } |
523 | 749 |
524 } // namespace webrtc | 750 } // namespace webrtc |
OLD | NEW |