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(0x11111111U, parser()->dlrr_items()->Ssrc(0)); | |
sprang_webrtc
2015/08/19 15:17:03
last_xr_rr.sourceSSRC
etc
åsapersson
2015/08/20 10:28:09
Done.
| |
587 EXPECT_EQ(0x22222222U, parser()->dlrr_items()->LastRr(0)); | |
588 EXPECT_EQ(0x33333333U, parser()->dlrr_items()->DelayLastRr(0)); | |
589 } | |
590 | |
591 TEST_F(RtcpSenderTest, SendXrWithRrtr) { | |
592 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
593 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); | |
594 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); | |
595 uint32_t ntp_secs; | |
596 uint32_t ntp_frac; | |
597 clock_.CurrentNtp(ntp_secs, ntp_frac); | |
598 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); | |
599 EXPECT_EQ(1, parser()->xr_header()->num_packets()); | |
600 EXPECT_EQ(kSenderSsrc, parser()->xr_header()->Ssrc()); | |
601 EXPECT_EQ(0, parser()->dlrr()->num_packets()); | |
602 EXPECT_EQ(1, parser()->rrtr()->num_packets()); | |
603 EXPECT_EQ(ntp_secs, parser()->rrtr()->NtpSec()); | |
604 EXPECT_EQ(ntp_frac, parser()->rrtr()->NtpFrac()); | |
605 } | |
606 | |
607 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) { | |
608 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
609 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); | |
610 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); | |
611 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); | |
612 EXPECT_EQ(0, parser()->xr_header()->num_packets()); | |
613 EXPECT_EQ(0, parser()->rrtr()->num_packets()); | |
614 } | |
615 | |
616 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) { | |
617 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
618 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); | |
619 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false); | |
620 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); | |
621 EXPECT_EQ(0, parser()->xr_header()->num_packets()); | |
622 EXPECT_EQ(0, parser()->rrtr()->num_packets()); | |
623 } | |
624 | |
625 TEST_F(RtcpSenderTest, TestSendTimeOfXrRrtr) { | |
413 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 626 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
414 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 627 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
415 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); | 628 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); | 629 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
450 uint32_t ntp_sec; | 630 uint32_t ntp_sec; |
451 uint32_t ntp_frac; | 631 uint32_t ntp_frac; |
452 clock_.CurrentNtp(ntp_sec, ntp_frac); | 632 clock_.CurrentNtp(ntp_sec, ntp_frac); |
453 uint32_t initial_mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); | 633 uint32_t initial_mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); |
454 | 634 |
455 // No packet sent. | 635 // No packet sent. |
456 int64_t time_ms; | 636 int64_t time_ms; |
457 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); | 637 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); |
458 | 638 |
459 // Send XR RR packets. | 639 // Send XR RR packets. |
460 for (int i = 0; i <= RTCP_NUMBER_OF_SR; ++i) { | 640 for (int i = 0; i <= RTCP_NUMBER_OF_SR; ++i) { |
461 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); | 641 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); |
462 EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & | 642 EXPECT_EQ(i + 1, test_transport_.parser_.rrtr()->num_packets()); |
463 kRtcpXrReceiverReferenceTime); | |
464 | |
465 clock_.CurrentNtp(ntp_sec, ntp_frac); | 643 clock_.CurrentNtp(ntp_sec, ntp_frac); |
466 uint32_t mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); | 644 uint32_t mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); |
467 EXPECT_TRUE(rtcp_sender_->SendTimeOfXrRrReport(mid_ntp, &time_ms)); | 645 EXPECT_TRUE(rtcp_sender_->SendTimeOfXrRrReport(mid_ntp, &time_ms)); |
468 EXPECT_EQ(clock_.CurrentNtpInMilliseconds(), time_ms); | 646 EXPECT_EQ(clock_.CurrentNtpInMilliseconds(), time_ms); |
469 clock_.AdvanceTimeMilliseconds(1000); | 647 clock_.AdvanceTimeMilliseconds(1000); |
470 } | 648 } |
471 | |
472 // The first report should no longer be stored. | 649 // The first report should no longer be stored. |
473 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); | 650 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); |
474 } | 651 } |
475 | 652 |
653 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) { | |
654 RtcpPacketTypeCounterObserverImpl observer; | |
655 rtcp_sender_.reset( | |
656 new RTCPSender(0, false, &clock_, receive_statistics_.get(), &observer)); | |
657 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); | |
658 EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(&test_transport_)); | |
659 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); | |
660 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); | |
661 EXPECT_EQ(1, parser()->pli()->num_packets()); | |
662 EXPECT_EQ(kRemoteSsrc, observer.ssrc_); | |
663 EXPECT_EQ(1U, observer.counter_.pli_packets); | |
664 EXPECT_EQ(clock_.TimeInMilliseconds(), | |
665 observer.counter_.first_packet_time_ms); | |
666 } | |
667 | |
668 TEST_F(RtcpSenderTest, SendTmmbr) { | |
669 const unsigned int kBitrateBps = 312000; | |
670 rtcp_sender_->SetRTCPStatus(kRtcpNonCompound); | |
671 rtcp_sender_->SetTargetBitrate(kBitrateBps); | |
672 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr)); | |
673 EXPECT_EQ(1, parser()->tmmbr()->num_packets()); | |
674 EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->Ssrc()); | |
675 EXPECT_EQ(1, parser()->tmmbr_item()->num_packets()); | |
676 EXPECT_EQ(kBitrateBps / 1000, parser()->tmmbr_item()->BitrateKbps()); | |
677 // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero. | |
678 } | |
679 | |
680 TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) { | |
681 const unsigned int kBitrateBps = 312000; | |
682 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
683 EXPECT_FALSE(rtcp_sender_->TMMBR()); | |
684 rtcp_sender_->SetTMMBRStatus(true); | |
685 EXPECT_TRUE(rtcp_sender_->TMMBR()); | |
686 rtcp_sender_->SetTargetBitrate(kBitrateBps); | |
687 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); | |
688 EXPECT_EQ(1, parser()->tmmbr()->num_packets()); | |
689 EXPECT_EQ(1, parser()->tmmbr_item()->num_packets()); | |
690 // TMMBR should be included in each compound packet. | |
691 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); | |
692 EXPECT_EQ(2, parser()->tmmbr()->num_packets()); | |
693 EXPECT_EQ(2, parser()->tmmbr_item()->num_packets()); | |
694 | |
695 rtcp_sender_->SetTMMBRStatus(false); | |
696 EXPECT_FALSE(rtcp_sender_->TMMBR()); | |
697 } | |
698 | |
699 TEST_F(RtcpSenderTest, SendTmmbn) { | |
700 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | |
701 TMMBRSet bounding_set; | |
702 bounding_set.VerifyAndAllocateSet(1); | |
703 const uint32_t kBitrateKbps = 32768; | |
704 const uint32_t kPacketOh = 40; | |
705 const uint32_t kSourceSsrc = 12345; | |
706 bounding_set.AddEntry(kBitrateKbps, kPacketOh, kSourceSsrc); | |
707 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 0)); | |
708 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); | |
709 EXPECT_EQ(1, parser()->sender_report()->num_packets()); | |
710 EXPECT_EQ(1, parser()->tmmbn()->num_packets()); | |
711 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc()); | |
712 EXPECT_EQ(1, parser()->tmmbn_items()->num_packets()); | |
713 EXPECT_EQ(kBitrateKbps, parser()->tmmbn_items()->BitrateKbps(0)); | |
714 EXPECT_EQ(kPacketOh, parser()->tmmbn_items()->Overhead(0)); | |
715 EXPECT_EQ(kSourceSsrc, parser()->tmmbn_items()->Ssrc(0)); | |
716 } | |
717 | |
476 // This test is written to verify actual behaviour. It does not seem | 718 // 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 | 719 // 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 | 720 // to put an actual limit here. It's just information that no limit |
479 // is set, which is kind of the starting assumption. | 721 // is set, which is kind of the starting assumption. |
480 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one | 722 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one |
481 // situation where this caused confusion. | 723 // situation where this caused confusion. |
482 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { | 724 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { |
483 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 725 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
484 TMMBRSet bounding_set; | 726 TMMBRSet bounding_set; |
485 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); | 727 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); |
486 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | 728 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
487 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); | 729 EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
488 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); | 730 EXPECT_EQ(1, parser()->tmmbn()->num_packets()); |
489 // We now expect the packet to show up in the rtcp_packet_info_ of | 731 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->Ssrc()); |
490 // test_transport_. | 732 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 } | 733 } |
500 | 734 |
501 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndValid) { | 735 TEST_F(RtcpSenderTest, SendCompoundPliRemb) { |
736 const int kBitrate = 261011; | |
737 std::vector<uint32_t> ssrcs; | |
738 ssrcs.push_back(kRemoteSsrc); | |
502 rtcp_sender_->SetRTCPStatus(kRtcpCompound); | 739 rtcp_sender_->SetRTCPStatus(kRtcpCompound); |
503 TMMBRSet bounding_set; | 740 rtcp_sender_->SetREMBData(kBitrate, ssrcs); |
504 bounding_set.VerifyAndAllocateSet(1); | 741 std::set<RTCPPacketType> packet_types; |
505 const uint32_t kSourceSsrc = 12345; | 742 packet_types.insert(kRtcpRemb); |
506 bounding_set.AddEntry(32768, 0, kSourceSsrc); | 743 packet_types.insert(kRtcpPli); |
507 | 744 EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types)); |
508 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); | 745 EXPECT_EQ(1, parser()->remb_item()->num_packets()); |
509 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); | 746 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 } | 747 } |
523 | 748 |
524 } // namespace webrtc | 749 } // namespace webrtc |
OLD | NEW |