media/cast/net/rtp/cast_message_builder_unittest.cc

   1 // Copyright 2014 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 <stdint.h>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/test/simple_test_tick_clock.h"
   9 #include "media/cast/net/rtcp/rtcp.h"
  10 #include "media/cast/net/rtp/cast_message_builder.h"
  11 #include "media/cast/net/rtp/framer.h"
  12 #include "media/cast/net/rtp/rtp_receiver_defines.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace media {
  16 namespace cast {
  17
  18 namespace {
  19 static const uint32 kSsrc = 0x1234;
  20 static const uint32 kShortTimeIncrementMs = 10;
  21 static const uint32 kLongTimeIncrementMs = 40;
  22 static const int64 kStartMillisecond = INT64_C(12345678900000);
  23
  24 typedef std::map<uint32, size_t> MissingPacketsMap;
  25
  26 class NackFeedbackVerification : public RtpPayloadFeedback {
  27  public:
  28   NackFeedbackVerification()
  29       : triggered_(false), missing_packets_(), last_frame_acked_(0) {}
  30
  31   void CastFeedback(const RtcpCastMessage& cast_feedback) final {
  32     EXPECT_EQ(kSsrc, cast_feedback.media_ssrc);
  33
  34     last_frame_acked_ = cast_feedback.ack_frame_id;
  35
  36     MissingFramesAndPacketsMap::const_iterator frame_it =
  37         cast_feedback.missing_frames_and_packets.begin();
  38
  39     // Keep track of the number of missing packets per frame.
  40     missing_packets_.clear();
  41     while (frame_it != cast_feedback.missing_frames_and_packets.end()) {
  42       // Check for complete frame lost.
  43       if ((frame_it->second.size() == 1) &&
  44           (*frame_it->second.begin() == kRtcpCastAllPacketsLost)) {
  45         missing_packets_.insert(
  46             std::make_pair(frame_it->first, kRtcpCastAllPacketsLost));
  47       } else {
  48         missing_packets_.insert(
  49             std::make_pair(frame_it->first, frame_it->second.size()));
  50       }
  51       ++frame_it;
  52     }
  53     triggered_ = true;
  54   }
  55
  56   size_t num_missing_packets(uint32 frame_id) {
  57     MissingPacketsMap::iterator it;
  58     it = missing_packets_.find(frame_id);
  59     if (it == missing_packets_.end())
  60       return 0;
  61
  62     return it->second;
  63   }
  64
  65   // Holds value for one call.
  66   bool triggered() {
  67     bool ret_val = triggered_;
  68     triggered_ = false;
  69     return ret_val;
  70   }
  71
  72   uint32 last_frame_acked() { return last_frame_acked_; }
  73
  74  private:
  75   bool triggered_;
  76   MissingPacketsMap missing_packets_;  // Missing packets per frame.
  77   uint32 last_frame_acked_;
  78
  79   DISALLOW_COPY_AND_ASSIGN(NackFeedbackVerification);
  80 };
  81 }  // namespace
  82
  83 class CastMessageBuilderTest : public ::testing::Test {
  84  protected:
  85   CastMessageBuilderTest()
  86       : framer_(&testing_clock_,
  87                 &feedback_,
  88                 kSsrc,
  89                 true,
  90                 10),
  91         cast_msg_builder_(new CastMessageBuilder(&testing_clock_,
  92                                                  &feedback_,
  93                                                  &framer_,
  94                                                  kSsrc,
  95                                                  true,
  96                                                  0)) {
  97     rtp_header_.sender_ssrc = kSsrc;
  98     rtp_header_.is_key_frame = false;
  99     testing_clock_.Advance(
 100         base::TimeDelta::FromMilliseconds(kStartMillisecond));
 101   }
 102
 103   ~CastMessageBuilderTest() override {}
 104
 105   void SetFrameIds(uint32 frame_id, uint32 reference_frame_id) {
 106     rtp_header_.frame_id = frame_id;
 107     rtp_header_.reference_frame_id = reference_frame_id;
 108   }
 109
 110   void SetPacketId(uint16 packet_id) { rtp_header_.packet_id = packet_id; }
 111
 112   void SetMaxPacketId(uint16 max_packet_id) {
 113     rtp_header_.max_packet_id = max_packet_id;
 114   }
 115
 116   void SetKeyFrame(bool is_key) { rtp_header_.is_key_frame = is_key; }
 117
 118   void InsertPacket() {
 119     bool duplicate;
 120     uint8 payload = 0;
 121     if (framer_.InsertPacket(&payload, 1, rtp_header_, &duplicate)) {
 122       cast_msg_builder_->CompleteFrameReceived(rtp_header_.frame_id);
 123     }
 124     cast_msg_builder_->UpdateCastMessage();
 125   }
 126
 127   void SetDecoderSlowerThanMaxFrameRate(int max_unacked_frames) {
 128     cast_msg_builder_.reset(new CastMessageBuilder(&testing_clock_,
 129                                                    &feedback_,
 130                                                    &framer_,
 131                                                    kSsrc,
 132                                                    false,
 133                                                    max_unacked_frames));
 134   }
 135
 136   NackFeedbackVerification feedback_;
 137   Framer framer_;
 138   scoped_ptr<CastMessageBuilder> cast_msg_builder_;
 139   RtpCastHeader rtp_header_;
 140   base::SimpleTestTickClock testing_clock_;
 141
 142   DISALLOW_COPY_AND_ASSIGN(CastMessageBuilderTest);
 143 };
 144
 145 TEST_F(CastMessageBuilderTest, OneFrameNackList) {
 146   SetFrameIds(0, 0);
 147   SetPacketId(4);
 148   SetMaxPacketId(10);
 149   InsertPacket();
 150   testing_clock_.Advance(
 151       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 152   EXPECT_FALSE(feedback_.triggered());
 153   testing_clock_.Advance(
 154       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 155   SetPacketId(5);
 156   InsertPacket();
 157   EXPECT_TRUE(feedback_.triggered());
 158   EXPECT_EQ(4u, feedback_.num_missing_packets(0));
 159 }
 160
 161 TEST_F(CastMessageBuilderTest, CompleteFrameMissing) {
 162   SetFrameIds(0, 0);
 163   SetPacketId(2);
 164   SetMaxPacketId(5);
 165   InsertPacket();
 166   testing_clock_.Advance(
 167       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 168   SetFrameIds(2, 1);
 169   SetPacketId(2);
 170   SetMaxPacketId(5);
 171   InsertPacket();
 172   EXPECT_TRUE(feedback_.triggered());
 173   EXPECT_EQ(kRtcpCastAllPacketsLost, feedback_.num_missing_packets(1));
 174 }
 175
 176 TEST_F(CastMessageBuilderTest, RemoveOldFrames) {
 177   SetFrameIds(1, 0);
 178   SetPacketId(0);
 179   SetMaxPacketId(1);
 180   InsertPacket();
 181   EXPECT_FALSE(feedback_.triggered());
 182   testing_clock_.Advance(
 183       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 184   SetFrameIds(2, 1);
 185   SetPacketId(0);
 186   SetMaxPacketId(0);
 187   InsertPacket();
 188   EXPECT_TRUE(feedback_.triggered());
 189   testing_clock_.Advance(
 190       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 191   SetFrameIds(3, 2);
 192   SetPacketId(0);
 193   SetMaxPacketId(5);
 194   InsertPacket();
 195   EXPECT_TRUE(feedback_.triggered());
 196   EXPECT_EQ(2u, feedback_.last_frame_acked());
 197   testing_clock_.Advance(
 198       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 199   SetFrameIds(5, 5);
 200   SetPacketId(0);
 201   SetMaxPacketId(0);
 202   SetKeyFrame(true);
 203   InsertPacket();
 204   testing_clock_.Advance(
 205       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 206   framer_.RemoveOldFrames(5);  // Simulate 5 being pulled for rendering.
 207   cast_msg_builder_->UpdateCastMessage();
 208   EXPECT_TRUE(feedback_.triggered());
 209   EXPECT_EQ(5u, feedback_.last_frame_acked());
 210   testing_clock_.Advance(
 211       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 212   SetFrameIds(1, 0);
 213   SetPacketId(1);
 214   SetMaxPacketId(1);
 215   InsertPacket();
 216   EXPECT_FALSE(feedback_.triggered());
 217   testing_clock_.Advance(
 218       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 219   InsertPacket();
 220   EXPECT_TRUE(feedback_.triggered());
 221   EXPECT_EQ(5u, feedback_.last_frame_acked());
 222 }
 223
 224 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacket) {
 225   SetFrameIds(0, 0);
 226   SetPacketId(0);
 227   SetMaxPacketId(20);
 228   SetKeyFrame(true);
 229   InsertPacket();
 230   testing_clock_.Advance(
 231       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 232   SetPacketId(5);
 233   InsertPacket();
 234   EXPECT_TRUE(feedback_.triggered());
 235   EXPECT_EQ(4u, feedback_.num_missing_packets(0));
 236 }
 237
 238 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacketNextFrame) {
 239   SetFrameIds(0, 0);
 240   SetPacketId(0);
 241   SetMaxPacketId(20);
 242   SetKeyFrame(true);
 243   InsertPacket();
 244   testing_clock_.Advance(
 245       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 246   SetPacketId(5);
 247   InsertPacket();
 248   testing_clock_.Advance(
 249       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 250   EXPECT_TRUE(feedback_.triggered());
 251   EXPECT_EQ(4u, feedback_.num_missing_packets(0));
 252   SetFrameIds(1, 0);
 253   SetMaxPacketId(2);
 254   SetPacketId(0);
 255   SetKeyFrame(false);
 256   InsertPacket();
 257   testing_clock_.Advance(
 258       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 259   EXPECT_TRUE(feedback_.triggered());
 260   EXPECT_EQ(19u, feedback_.num_missing_packets(0));
 261 }
 262
 263 TEST_F(CastMessageBuilderTest, NackUntilMaxReceivedPacketNextKey) {
 264   SetFrameIds(0, 0);
 265   SetPacketId(0);
 266   SetMaxPacketId(20);
 267   SetKeyFrame(true);
 268   InsertPacket();
 269   testing_clock_.Advance(
 270       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 271   SetPacketId(5);
 272   InsertPacket();
 273   testing_clock_.Advance(
 274       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 275   EXPECT_TRUE(feedback_.triggered());
 276   EXPECT_EQ(4u, feedback_.num_missing_packets(0));
 277   SetFrameIds(1, 1);
 278   SetMaxPacketId(0);
 279   SetPacketId(0);
 280   SetKeyFrame(true);
 281   InsertPacket();
 282   testing_clock_.Advance(
 283       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 284   EXPECT_TRUE(feedback_.triggered());
 285   EXPECT_EQ(0u, feedback_.num_missing_packets(0));
 286 }
 287
 288 TEST_F(CastMessageBuilderTest, Reset) {
 289   InsertPacket();
 290   testing_clock_.Advance(
 291       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 292   cast_msg_builder_->Reset();
 293   framer_.Reset();
 294   // Should reset nack list state and request a key frame.
 295   cast_msg_builder_->UpdateCastMessage();
 296   EXPECT_TRUE(feedback_.triggered());
 297   EXPECT_EQ(0u, feedback_.num_missing_packets(0));
 298 }
 299
 300 TEST_F(CastMessageBuilderTest, DeltaAfterReset) {
 301   SetFrameIds(0, 0);
 302   SetPacketId(0);
 303   SetMaxPacketId(0);
 304   SetKeyFrame(true);
 305   InsertPacket();
 306   EXPECT_TRUE(feedback_.triggered());
 307   EXPECT_EQ(0u, feedback_.num_missing_packets(0));
 308   testing_clock_.Advance(
 309       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 310   cast_msg_builder_->Reset();
 311   SetFrameIds(1, 0);
 312   SetPacketId(0);
 313   SetMaxPacketId(0);
 314   SetKeyFrame(true);
 315   EXPECT_FALSE(feedback_.triggered());
 316 }
 317
 318 TEST_F(CastMessageBuilderTest, BasicRps) {
 319   SetFrameIds(0, 0);
 320   SetPacketId(0);
 321   SetMaxPacketId(0);
 322   SetKeyFrame(true);
 323   InsertPacket();
 324   testing_clock_.Advance(
 325       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 326   EXPECT_TRUE(feedback_.triggered());
 327   EXPECT_EQ(0u, feedback_.last_frame_acked());
 328   SetFrameIds(3, 0);
 329   SetKeyFrame(false);
 330   InsertPacket();
 331   EXPECT_TRUE(feedback_.triggered());
 332   EXPECT_EQ(3u, feedback_.last_frame_acked());
 333   testing_clock_.Advance(
 334       base::TimeDelta::FromMilliseconds(kLongTimeIncrementMs));
 335   framer_.RemoveOldFrames(3);  // Simulate 3 being pulled for rendering.
 336   cast_msg_builder_->UpdateCastMessage();
 337   EXPECT_TRUE(feedback_.triggered());
 338   EXPECT_EQ(3u, feedback_.last_frame_acked());
 339 }
 340
 341 TEST_F(CastMessageBuilderTest, InOrderRps) {
 342   // Create a pattern - skip to rps, and don't look back.
 343   SetFrameIds(0, 0);
 344   SetPacketId(0);
 345   SetMaxPacketId(0);
 346   SetKeyFrame(true);
 347   InsertPacket();
 348   testing_clock_.Advance(
 349       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 350   EXPECT_TRUE(feedback_.triggered());
 351   EXPECT_EQ(0u, feedback_.last_frame_acked());
 352   SetFrameIds(1, 0);
 353   SetPacketId(0);
 354   SetMaxPacketId(1);
 355   SetKeyFrame(false);
 356   InsertPacket();
 357   testing_clock_.Advance(
 358       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 359   EXPECT_FALSE(feedback_.triggered());
 360   SetFrameIds(3, 0);
 361   SetPacketId(0);
 362   SetMaxPacketId(0);
 363   SetKeyFrame(false);
 364   InsertPacket();
 365   testing_clock_.Advance(
 366       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 367   framer_.RemoveOldFrames(3);  // Simulate 3 being pulled for rendering.
 368   testing_clock_.Advance(
 369       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 370   cast_msg_builder_->UpdateCastMessage();
 371   EXPECT_TRUE(feedback_.triggered());
 372   EXPECT_EQ(3u, feedback_.last_frame_acked());
 373   // Make an old frame complete - should not trigger an ack.
 374   SetFrameIds(1, 0);
 375   SetPacketId(1);
 376   SetMaxPacketId(1);
 377   SetKeyFrame(false);
 378   InsertPacket();
 379   testing_clock_.Advance(
 380       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 381   EXPECT_FALSE(feedback_.triggered());
 382   EXPECT_EQ(3u, feedback_.last_frame_acked());
 383 }
 384
 385 TEST_F(CastMessageBuilderTest, SlowDownAck) {
 386   SetDecoderSlowerThanMaxFrameRate(3);
 387   SetFrameIds(0, 0);
 388   SetPacketId(0);
 389   SetMaxPacketId(0);
 390   SetKeyFrame(true);
 391   InsertPacket();
 392
 393   uint32 frame_id;
 394   testing_clock_.Advance(
 395       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 396   SetKeyFrame(false);
 397   for (frame_id = 1; frame_id < 3; ++frame_id) {
 398     EXPECT_TRUE(feedback_.triggered());
 399     EXPECT_EQ(frame_id - 1, feedback_.last_frame_acked());
 400     SetFrameIds(frame_id, frame_id - 1);
 401     InsertPacket();
 402     testing_clock_.Advance(
 403         base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 404   }
 405   // We should now have entered the slowdown ACK state.
 406   uint32 expected_frame_id = 1;
 407   for (; frame_id < 10; ++frame_id) {
 408     if (frame_id % 2) {
 409       ++expected_frame_id;
 410       EXPECT_TRUE(feedback_.triggered());
 411     } else {
 412       EXPECT_FALSE(feedback_.triggered());
 413     }
 414     EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked());
 415     SetFrameIds(frame_id, frame_id - 1);
 416     InsertPacket();
 417     testing_clock_.Advance(
 418         base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 419   }
 420   EXPECT_FALSE(feedback_.triggered());
 421   EXPECT_EQ(expected_frame_id, feedback_.last_frame_acked());
 422
 423   // Simulate frame_id being pulled for rendering.
 424   framer_.RemoveOldFrames(frame_id);
 425   // We should now leave the slowdown ACK state.
 426   ++frame_id;
 427   SetFrameIds(frame_id, frame_id - 1);
 428   InsertPacket();
 429   testing_clock_.Advance(
 430       base::TimeDelta::FromMilliseconds(kShortTimeIncrementMs));
 431   EXPECT_TRUE(feedback_.triggered());
 432   EXPECT_EQ(frame_id, feedback_.last_frame_acked());
 433 }
 434
 435 }  // namespace cast
 436 }  // namespace media