media/cast/rtcp/rtcp_sender_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/test/simple_test_tick_clock.h"
   7 #include "media/cast/cast_defines.h"
   8 #include "media/cast/cast_environment.h"
   9 #include "media/cast/rtcp/rtcp_sender.h"
  10 #include "media/cast/rtcp/rtcp_utility.h"
  11 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
  12 #include "media/cast/test/fake_task_runner.h"
  13 #include "media/cast/transport/cast_transport_defines.h"
  14 #include "media/cast/transport/pacing/paced_sender.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16
  17 namespace media {
  18 namespace cast {
  19
  20 namespace {
  21 static const uint32 kSendingSsrc = 0x12345678;
  22 static const uint32 kMediaSsrc = 0x87654321;
  23 static const std::string kCName("test@10.1.1.1");
  24 }  // namespace
  25
  26 class TestRtcpTransport : public transport::PacedPacketSender {
  27  public:
  28   TestRtcpTransport()
  29       : expected_packet_length_(0),
  30         packet_count_(0) {
  31   }
  32
  33   virtual bool SendRtcpPacket(const Packet& packet) OVERRIDE {
  34     EXPECT_EQ(expected_packet_length_, packet.size());
  35     EXPECT_EQ(0, memcmp(expected_packet_, &(packet[0]), packet.size()));
  36     packet_count_++;
  37     return true;
  38   }
  39
  40   virtual bool SendPackets(const PacketList& packets) OVERRIDE {
  41     return false;
  42   }
  43
  44   virtual bool ResendPackets(const PacketList& packets) OVERRIDE {
  45     return false;
  46   }
  47
  48   void SetExpectedRtcpPacket(const uint8* rtcp_buffer, size_t length) {
  49     expected_packet_length_ = length;
  50     memcpy(expected_packet_, rtcp_buffer, length);
  51   }
  52
  53   int packet_count() const { return packet_count_; }
  54
  55  private:
  56   uint8 expected_packet_[kMaxIpPacketSize];
  57   size_t expected_packet_length_;
  58   int packet_count_;
  59 };
  60
  61 class RtcpSenderTest : public ::testing::Test {
  62  protected:
  63   RtcpSenderTest()
  64       : task_runner_(new test::FakeTaskRunner(&testing_clock_)),
  65         cast_environment_(new CastEnvironment(&testing_clock_, task_runner_,
  66             task_runner_, task_runner_, task_runner_, task_runner_,
  67             task_runner_, GetDefaultCastLoggingConfig())),
  68         rtcp_sender_(new RtcpSender(cast_environment_,
  69                                     &test_transport_,
  70                                     kSendingSsrc,
  71                                     kCName)) {
  72   }
  73
  74   base::SimpleTestTickClock testing_clock_;
  75   TestRtcpTransport test_transport_;
  76   scoped_refptr<test::FakeTaskRunner> task_runner_;
  77   scoped_refptr<CastEnvironment> cast_environment_;
  78   scoped_ptr<RtcpSender> rtcp_sender_;
  79 };
  80
  81 TEST_F(RtcpSenderTest, RtcpReceiverReport) {
  82   // Empty receiver report + c_name.
  83   TestRtcpPacketBuilder p1;
  84   p1.AddRr(kSendingSsrc, 0);
  85   p1.AddSdesCname(kSendingSsrc, kCName);
  86   test_transport_.SetExpectedRtcpPacket(p1.Packet(), p1.Length());
  87
  88   rtcp_sender_->SendRtcpFromRtpReceiver(RtcpSender::kRtcpRr,
  89       NULL, NULL, NULL, NULL);
  90
  91   EXPECT_EQ(1, test_transport_.packet_count());
  92
  93   // Receiver report with report block + c_name.
  94   TestRtcpPacketBuilder p2;
  95   p2.AddRr(kSendingSsrc, 1);
  96   p2.AddRb(kMediaSsrc);
  97   p2.AddSdesCname(kSendingSsrc, kCName);
  98   test_transport_.SetExpectedRtcpPacket(p2.Packet(), p2.Length());
  99
 100   transport::RtcpReportBlock report_block;
 101   // Initialize remote_ssrc to a "clearly illegal" value.
 102   report_block.remote_ssrc = 0xDEAD;
 103   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 104   report_block.fraction_lost = kLoss >> 24;
 105   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 106   report_block.extended_high_sequence_number = kExtendedMax;
 107   report_block.jitter = kTestJitter;
 108   report_block.last_sr = kLastSr;
 109   report_block.delay_since_last_sr = kDelayLastSr;
 110
 111   rtcp_sender_->SendRtcpFromRtpReceiver(RtcpSender::kRtcpRr, &report_block,
 112                                         NULL, NULL, NULL);
 113
 114   EXPECT_EQ(2, test_transport_.packet_count());
 115 }
 116
 117 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
 118   // Receiver report with report block + c_name.
 119   TestRtcpPacketBuilder p;
 120   p.AddRr(kSendingSsrc, 1);
 121   p.AddRb(kMediaSsrc);
 122   p.AddSdesCname(kSendingSsrc, kCName);
 123   p.AddXrHeader(kSendingSsrc);
 124   p.AddXrRrtrBlock();
 125   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 126
 127   transport::RtcpReportBlock report_block;
 128   // Initialize remote_ssrc to a "clearly illegal" value.
 129   report_block.remote_ssrc = 0xDEAD;
 130   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 131   report_block.fraction_lost = kLoss >> 24;
 132   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 133   report_block.extended_high_sequence_number = kExtendedMax;
 134   report_block.jitter = kTestJitter;
 135   report_block.last_sr = kLastSr;
 136   report_block.delay_since_last_sr = kDelayLastSr;
 137
 138   RtcpReceiverReferenceTimeReport rrtr;
 139   rrtr.ntp_seconds = kNtpHigh;
 140   rrtr.ntp_fraction = kNtpLow;
 141
 142   rtcp_sender_->SendRtcpFromRtpReceiver(
 143       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr,
 144       &report_block,
 145       &rrtr,
 146       NULL,
 147       NULL);
 148
 149   EXPECT_EQ(1, test_transport_.packet_count());
 150 }
 151
 152 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
 153   // Receiver report with report block + c_name.
 154   TestRtcpPacketBuilder p;
 155   p.AddRr(kSendingSsrc, 1);
 156   p.AddRb(kMediaSsrc);
 157   p.AddSdesCname(kSendingSsrc, kCName);
 158   p.AddCast(kSendingSsrc, kMediaSsrc);
 159   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 160
 161   transport::RtcpReportBlock report_block;
 162   // Initialize remote_ssrc to a "clearly illegal" value.
 163   report_block.remote_ssrc = 0xDEAD;
 164   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 165   report_block.fraction_lost = kLoss >> 24;
 166   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 167   report_block.extended_high_sequence_number = kExtendedMax;
 168   report_block.jitter = kTestJitter;
 169   report_block.last_sr = kLastSr;
 170   report_block.delay_since_last_sr = kDelayLastSr;
 171
 172   RtcpCastMessage cast_message(kMediaSsrc);
 173   cast_message.ack_frame_id_ = kAckFrameId;
 174   PacketIdSet missing_packets;
 175   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 176
 177   missing_packets.insert(kLostPacketId1);
 178   missing_packets.insert(kLostPacketId2);
 179   missing_packets.insert(kLostPacketId3);
 180   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 181       missing_packets;
 182
 183   rtcp_sender_->SendRtcpFromRtpReceiver(
 184       RtcpSender::kRtcpRr | RtcpSender::kRtcpCast,
 185       &report_block,
 186       NULL,
 187       &cast_message,
 188       NULL);
 189
 190   EXPECT_EQ(1, test_transport_.packet_count());
 191 }
 192
 193 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) {
 194   TestRtcpPacketBuilder p;
 195   p.AddRr(kSendingSsrc, 1);
 196   p.AddRb(kMediaSsrc);
 197   p.AddSdesCname(kSendingSsrc, kCName);
 198   p.AddXrHeader(kSendingSsrc);
 199   p.AddXrRrtrBlock();
 200   p.AddCast(kSendingSsrc, kMediaSsrc);
 201   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 202
 203   transport::RtcpReportBlock report_block;
 204   // Initialize remote_ssrc to a "clearly illegal" value.
 205   report_block.remote_ssrc = 0xDEAD;
 206   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 207   report_block.fraction_lost = kLoss >> 24;
 208   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 209   report_block.extended_high_sequence_number = kExtendedMax;
 210   report_block.jitter = kTestJitter;
 211   report_block.last_sr = kLastSr;
 212   report_block.delay_since_last_sr = kDelayLastSr;
 213
 214   RtcpReceiverReferenceTimeReport rrtr;
 215   rrtr.ntp_seconds = kNtpHigh;
 216   rrtr.ntp_fraction = kNtpLow;
 217
 218   RtcpCastMessage cast_message(kMediaSsrc);
 219   cast_message.ack_frame_id_ = kAckFrameId;
 220   PacketIdSet missing_packets;
 221   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 222
 223   missing_packets.insert(kLostPacketId1);
 224   missing_packets.insert(kLostPacketId2);
 225   missing_packets.insert(kLostPacketId3);
 226   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 227       missing_packets;
 228
 229   rtcp_sender_->SendRtcpFromRtpReceiver(
 230       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast,
 231       &report_block,
 232       &rrtr,
 233       &cast_message,
 234       NULL);
 235
 236   EXPECT_EQ(1, test_transport_.packet_count());
 237 }
 238
 239 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) {
 240   static const uint32 kTimeBaseMs = 12345678;
 241   static const uint32 kTimeDelayMs = 10;
 242   static const uint32 kDelayDeltaMs = 123;
 243
 244   TestRtcpPacketBuilder p;
 245   p.AddRr(kSendingSsrc, 1);
 246   p.AddRb(kMediaSsrc);
 247   p.AddSdesCname(kSendingSsrc, kCName);
 248   p.AddXrHeader(kSendingSsrc);
 249   p.AddXrRrtrBlock();
 250   p.AddCast(kSendingSsrc, kMediaSsrc);
 251   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 252
 253   transport::RtcpReportBlock report_block;
 254   // Initialize remote_ssrc to a "clearly illegal" value.
 255   report_block.remote_ssrc = 0xDEAD;
 256   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 257   report_block.fraction_lost = kLoss >> 24;
 258   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 259   report_block.extended_high_sequence_number = kExtendedMax;
 260   report_block.jitter = kTestJitter;
 261   report_block.last_sr = kLastSr;
 262   report_block.delay_since_last_sr = kDelayLastSr;
 263
 264   RtcpReceiverReferenceTimeReport rrtr;
 265   rrtr.ntp_seconds = kNtpHigh;
 266   rrtr.ntp_fraction = kNtpLow;
 267
 268   RtcpCastMessage cast_message(kMediaSsrc);
 269   cast_message.ack_frame_id_ = kAckFrameId;
 270   PacketIdSet missing_packets;
 271   cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets;
 272
 273   missing_packets.insert(kLostPacketId1);
 274   missing_packets.insert(kLostPacketId2);
 275   missing_packets.insert(kLostPacketId3);
 276   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 277       missing_packets;
 278
 279   // Test empty Log message.
 280   RtcpReceiverLogMessage receiver_log;
 281
 282   VLOG(0) << " Test empty Log  " ;
 283   rtcp_sender_->SendRtcpFromRtpReceiver(
 284       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast |
 285       RtcpSender::kRtcpReceiverLog,
 286       &report_block,
 287       &rrtr,
 288       &cast_message,
 289       &receiver_log);
 290
 291
 292   base::SimpleTestTickClock testing_clock;
 293   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 294
 295   p.AddReceiverLog(kSendingSsrc);
 296   p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs);
 297   p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
 298   p.AddReceiverEventLog(kLostPacketId1, 6, kTimeDelayMs);
 299
 300   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 301
 302   RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
 303   RtcpReceiverEventLogMessage event_log;
 304
 305   event_log.type = kAckSent;
 306   event_log.event_timestamp = testing_clock.NowTicks();
 307   event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
 308   frame_log.event_log_messages_.push_back(event_log);
 309
 310   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 311   event_log.type = kPacketReceived;
 312   event_log.event_timestamp = testing_clock.NowTicks();
 313   event_log.packet_id = kLostPacketId1;
 314   frame_log.event_log_messages_.push_back(event_log);
 315
 316   receiver_log.push_back(frame_log);
 317
 318   VLOG(0) << " Test  Log  " ;
 319   rtcp_sender_->SendRtcpFromRtpReceiver(
 320       RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr | RtcpSender::kRtcpCast |
 321       RtcpSender::kRtcpReceiverLog,
 322       &report_block,
 323       &rrtr,
 324       &cast_message,
 325       &receiver_log);
 326
 327   EXPECT_TRUE(receiver_log.empty());
 328   EXPECT_EQ(2, test_transport_.packet_count());
 329 }
 330
 331 TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) {
 332   static const uint32 kTimeBaseMs = 12345678;
 333   static const uint32 kTimeDelayMs = 10;
 334   static const uint32 kDelayDeltaMs = 123;
 335
 336   TestRtcpPacketBuilder p;
 337   p.AddRr(kSendingSsrc, 1);
 338   p.AddRb(kMediaSsrc);
 339   p.AddSdesCname(kSendingSsrc, kCName);
 340
 341   transport::RtcpReportBlock report_block;
 342   // Initialize remote_ssrc to a "clearly illegal" value.
 343   report_block.remote_ssrc = 0xDEAD;
 344   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 345   report_block.fraction_lost = kLoss >> 24;
 346   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 347   report_block.extended_high_sequence_number = kExtendedMax;
 348   report_block.jitter = kTestJitter;
 349   report_block.last_sr = kLastSr;
 350   report_block.delay_since_last_sr = kDelayLastSr;
 351
 352   base::SimpleTestTickClock testing_clock;
 353   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 354
 355   p.AddReceiverLog(kSendingSsrc);
 356
 357   p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs);
 358   p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
 359   p.AddReceiverFrameLog(kRtpTimestamp + 2345,
 360       kRtcpMaxReceiverLogMessages, kTimeBaseMs);
 361
 362   for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) {
 363     p.AddReceiverEventLog(
 364         kLostPacketId1, 6, static_cast<uint16>(kTimeDelayMs * i));
 365   }
 366
 367   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 368
 369   RtcpReceiverFrameLogMessage frame_1_log(kRtpTimestamp);
 370   RtcpReceiverEventLogMessage event_log;
 371
 372   event_log.type = kAckSent;
 373   event_log.event_timestamp = testing_clock.NowTicks();
 374   event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
 375   frame_1_log.event_log_messages_.push_back(event_log);
 376
 377   RtcpReceiverLogMessage receiver_log;
 378   receiver_log.push_back(frame_1_log);
 379
 380   RtcpReceiverFrameLogMessage frame_2_log(kRtpTimestamp + 2345);
 381
 382   for (int j = 0; j < 300; ++j) {
 383     event_log.type = kPacketReceived;
 384     event_log.event_timestamp = testing_clock.NowTicks();
 385     event_log.packet_id = kLostPacketId1;
 386     frame_2_log.event_log_messages_.push_back(event_log);
 387     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 388   }
 389   receiver_log.push_back(frame_2_log);
 390
 391   rtcp_sender_->SendRtcpFromRtpReceiver(
 392       RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog,
 393       &report_block,
 394       NULL,
 395       NULL,
 396       &receiver_log);
 397
 398   EXPECT_EQ(1, test_transport_.packet_count());
 399   EXPECT_EQ(1u, receiver_log.size());
 400   EXPECT_EQ(300u - kRtcpMaxReceiverLogMessages,
 401             receiver_log.front().event_log_messages_.size());
 402 }
 403
 404 TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) {
 405   static const uint32 kTimeBaseMs = 12345678;
 406   static const uint32 kTimeDelayMs = 10;
 407   static const uint32 kDelayDeltaMs = 123;
 408
 409   TestRtcpPacketBuilder p;
 410   p.AddRr(kSendingSsrc, 1);
 411   p.AddRb(kMediaSsrc);
 412   p.AddSdesCname(kSendingSsrc, kCName);
 413
 414   transport::RtcpReportBlock report_block;
 415   // Initialize remote_ssrc to a "clearly illegal" value.
 416   report_block.remote_ssrc = 0xDEAD;
 417   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 418   report_block.fraction_lost = kLoss >> 24;
 419   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 420   report_block.extended_high_sequence_number = kExtendedMax;
 421   report_block.jitter = kTestJitter;
 422   report_block.last_sr = kLastSr;
 423   report_block.delay_since_last_sr = kDelayLastSr;
 424
 425   base::SimpleTestTickClock testing_clock;
 426   testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs));
 427
 428   p.AddReceiverLog(kSendingSsrc);
 429
 430   for (int i = 0; i < 119; ++i) {
 431     p.AddReceiverFrameLog(kRtpTimestamp, 1, kTimeBaseMs +  i * kTimeDelayMs);
 432     p.AddReceiverEventLog(kDelayDeltaMs, 1, 0);
 433   }
 434   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 435
 436   RtcpReceiverLogMessage receiver_log;
 437
 438   for (int j = 0; j < 200; ++j) {
 439     RtcpReceiverFrameLogMessage frame_log(kRtpTimestamp);
 440     RtcpReceiverEventLogMessage event_log;
 441
 442     event_log.type = kAckSent;
 443     event_log.event_timestamp = testing_clock.NowTicks();
 444     event_log.delay_delta = base::TimeDelta::FromMilliseconds(kDelayDeltaMs);
 445     frame_log.event_log_messages_.push_back(event_log);
 446     receiver_log.push_back(frame_log);
 447     testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs));
 448   }
 449   rtcp_sender_->SendRtcpFromRtpReceiver(
 450       RtcpSender::kRtcpRr | RtcpSender::kRtcpReceiverLog,
 451       &report_block,
 452       NULL,
 453       NULL,
 454       &receiver_log);
 455
 456   EXPECT_EQ(1, test_transport_.packet_count());
 457   EXPECT_EQ(81u, receiver_log.size());
 458 }
 459
 460 }  // namespace cast
 461 }  // namespace media