src/media/cast/framer/framer_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/test/simple_test_tick_clock.h"
   6 #include "media/cast/framer/framer.h"
   7 #include "media/cast/rtp_receiver/mock_rtp_payload_feedback.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace media {
  11 namespace cast {
  12
  13 class FramerTest : public ::testing::Test {
  14  protected:
  15   FramerTest()
  16       : mock_rtp_payload_feedback_(),
  17         framer_(&testing_clock_, &mock_rtp_payload_feedback_, 0, true, 0) {
  18     // Build a default one packet frame - populate webrtc header.
  19     rtp_header_.is_key_frame = false;
  20     rtp_header_.frame_id = 0;
  21     rtp_header_.packet_id = 0;
  22     rtp_header_.max_packet_id = 0;
  23     rtp_header_.is_reference = false;
  24     rtp_header_.reference_frame_id = 0;
  25     payload_.assign(kMaxIpPacketSize, 0);
  26
  27     EXPECT_CALL(mock_rtp_payload_feedback_, CastFeedback(testing::_))
  28         .WillRepeatedly(testing::Return());
  29   }
  30
  31   virtual ~FramerTest() {}
  32
  33   std::vector<uint8> payload_;
  34   RtpCastHeader rtp_header_;
  35   MockRtpPayloadFeedback mock_rtp_payload_feedback_;
  36   Framer framer_;
  37   base::SimpleTestTickClock testing_clock_;
  38
  39   DISALLOW_COPY_AND_ASSIGN(FramerTest);
  40 };
  41
  42 TEST_F(FramerTest, EmptyState) {
  43   transport::EncodedVideoFrame frame;
  44   bool next_frame = false;
  45   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
  46 }
  47
  48 TEST_F(FramerTest, AlwaysStartWithKey) {
  49   transport::EncodedVideoFrame frame;
  50   bool next_frame = false;
  51   bool complete = false;
  52   bool duplicate = false;
  53
  54   // Insert non key first frame.
  55   complete = framer_.InsertPacket(
  56       payload_.data(), payload_.size(), rtp_header_, &duplicate);
  57   EXPECT_TRUE(complete);
  58   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
  59   rtp_header_.frame_id = 1;
  60   rtp_header_.is_key_frame = true;
  61   complete = framer_.InsertPacket(
  62       payload_.data(), payload_.size(), rtp_header_, &duplicate);
  63   EXPECT_TRUE(complete);
  64   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
  65   EXPECT_TRUE(next_frame);
  66   EXPECT_EQ(1u, frame.frame_id);
  67   EXPECT_TRUE(frame.key_frame);
  68   framer_.ReleaseFrame(frame.frame_id);
  69 }
  70
  71 TEST_F(FramerTest, CompleteFrame) {
  72   transport::EncodedVideoFrame frame;
  73   bool next_frame = false;
  74   bool complete = false;
  75   bool duplicate = false;
  76
  77   // Start with a complete key frame.
  78   rtp_header_.is_key_frame = true;
  79   complete = framer_.InsertPacket(
  80       payload_.data(), payload_.size(), rtp_header_, &duplicate);
  81   EXPECT_TRUE(complete);
  82   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
  83   EXPECT_TRUE(next_frame);
  84   EXPECT_EQ(0u, frame.frame_id);
  85   EXPECT_TRUE(frame.key_frame);
  86   framer_.ReleaseFrame(frame.frame_id);
  87
  88   // Incomplete delta.
  89   ++rtp_header_.frame_id;
  90   rtp_header_.is_key_frame = false;
  91   rtp_header_.max_packet_id = 2;
  92   complete = framer_.InsertPacket(
  93       payload_.data(), payload_.size(), rtp_header_, &duplicate);
  94   EXPECT_FALSE(complete);
  95   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
  96
  97   // Complete delta - can't skip, as incomplete sequence.
  98   ++rtp_header_.frame_id;
  99   rtp_header_.max_packet_id = 0;
 100   complete = framer_.InsertPacket(
 101       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 102   EXPECT_TRUE(complete);
 103   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 104 }
 105
 106 TEST_F(FramerTest, DuplicatePackets) {
 107   transport::EncodedVideoFrame frame;
 108   bool next_frame = false;
 109   bool complete = false;
 110   bool duplicate = false;
 111
 112   // Start with an incomplete key frame.
 113   rtp_header_.is_key_frame = true;
 114   rtp_header_.max_packet_id = 1;
 115   duplicate = true;
 116   complete = framer_.InsertPacket(
 117       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 118   EXPECT_FALSE(complete);
 119   EXPECT_FALSE(duplicate);
 120   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 121
 122   // Add same packet again in incomplete key frame.
 123   duplicate = false;
 124   complete = framer_.InsertPacket(
 125       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 126   EXPECT_FALSE(complete);
 127   EXPECT_TRUE(duplicate);
 128   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 129
 130   // Complete key frame.
 131   rtp_header_.packet_id = 1;
 132   duplicate = true;
 133   complete = framer_.InsertPacket(
 134       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 135   EXPECT_TRUE(complete);
 136   EXPECT_FALSE(duplicate);
 137   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 138   EXPECT_EQ(0u, frame.frame_id);
 139
 140   // Add same packet again in complete key frame.
 141   duplicate = false;
 142   complete = framer_.InsertPacket(
 143       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 144   EXPECT_FALSE(complete);
 145   EXPECT_TRUE(duplicate);
 146   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 147   EXPECT_EQ(0u, frame.frame_id);
 148   framer_.ReleaseFrame(frame.frame_id);
 149
 150   // Incomplete delta frame.
 151   ++rtp_header_.frame_id;
 152   rtp_header_.packet_id = 0;
 153   rtp_header_.is_key_frame = false;
 154   duplicate = true;
 155   complete = framer_.InsertPacket(
 156       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 157   EXPECT_FALSE(complete);
 158   EXPECT_FALSE(duplicate);
 159   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 160
 161   // Add same packet again in incomplete delta frame.
 162   duplicate = false;
 163   complete = framer_.InsertPacket(
 164       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 165   EXPECT_FALSE(complete);
 166   EXPECT_TRUE(duplicate);
 167   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 168
 169   // Complete delta frame.
 170   rtp_header_.packet_id = 1;
 171   duplicate = true;
 172   complete = framer_.InsertPacket(
 173       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 174   EXPECT_TRUE(complete);
 175   EXPECT_FALSE(duplicate);
 176   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 177   EXPECT_EQ(1u, frame.frame_id);
 178
 179   // Add same packet again in complete delta frame.
 180   duplicate = false;
 181   complete = framer_.InsertPacket(
 182       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 183   EXPECT_FALSE(complete);
 184   EXPECT_TRUE(duplicate);
 185   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 186   EXPECT_EQ(1u, frame.frame_id);
 187 }
 188
 189 TEST_F(FramerTest, ContinuousSequence) {
 190   transport::EncodedVideoFrame frame;
 191   bool next_frame = false;
 192   bool complete = false;
 193   bool duplicate = false;
 194
 195   // Start with a complete key frame.
 196   rtp_header_.is_key_frame = true;
 197   complete = framer_.InsertPacket(
 198       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 199   EXPECT_TRUE(complete);
 200   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 201   EXPECT_TRUE(next_frame);
 202   EXPECT_EQ(0u, frame.frame_id);
 203   EXPECT_TRUE(frame.key_frame);
 204   framer_.ReleaseFrame(frame.frame_id);
 205
 206   // Complete - not continuous.
 207   rtp_header_.frame_id = 2;
 208   rtp_header_.is_key_frame = false;
 209   complete = framer_.InsertPacket(
 210       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 211   EXPECT_TRUE(complete);
 212   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 213 }
 214
 215 TEST_F(FramerTest, Wrap) {
 216   // Insert key frame, frame_id = 255 (will jump to that)
 217   transport::EncodedVideoFrame frame;
 218   bool next_frame = false;
 219   bool duplicate = false;
 220
 221   // Start with a complete key frame.
 222   rtp_header_.is_key_frame = true;
 223   rtp_header_.frame_id = 255u;
 224   framer_.InsertPacket(
 225       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 226   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 227   EXPECT_TRUE(next_frame);
 228   EXPECT_EQ(255u, frame.frame_id);
 229   framer_.ReleaseFrame(frame.frame_id);
 230
 231   // Insert wrapped delta frame - should be continuous.
 232   rtp_header_.is_key_frame = false;
 233   rtp_header_.frame_id = 256;
 234   framer_.InsertPacket(
 235       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 236   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 237   EXPECT_TRUE(next_frame);
 238   EXPECT_EQ(256u, frame.frame_id);
 239   framer_.ReleaseFrame(frame.frame_id);
 240 }
 241
 242 TEST_F(FramerTest, Reset) {
 243   transport::EncodedVideoFrame frame;
 244   bool next_frame = false;
 245   bool complete = false;
 246   bool duplicate = false;
 247
 248   // Start with a complete key frame.
 249   rtp_header_.is_key_frame = true;
 250   complete = framer_.InsertPacket(
 251       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 252   EXPECT_TRUE(complete);
 253   framer_.Reset();
 254   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 255 }
 256
 257 TEST_F(FramerTest, RequireKeyAfterReset) {
 258   transport::EncodedVideoFrame frame;
 259   bool next_frame = false;
 260   bool duplicate = false;
 261
 262   framer_.Reset();
 263
 264   // Start with a complete key frame.
 265   rtp_header_.is_key_frame = false;
 266   rtp_header_.frame_id = 0u;
 267   framer_.InsertPacket(
 268       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 269   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 270   rtp_header_.frame_id = 1;
 271   rtp_header_.is_key_frame = true;
 272   framer_.InsertPacket(
 273       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 274   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 275   EXPECT_TRUE(next_frame);
 276 }
 277
 278 TEST_F(FramerTest, BasicNonLastReferenceId) {
 279   transport::EncodedVideoFrame frame;
 280   bool next_frame = false;
 281   bool duplicate = false;
 282
 283   rtp_header_.is_key_frame = true;
 284   rtp_header_.frame_id = 0;
 285   framer_.InsertPacket(
 286       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 287
 288   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 289   framer_.ReleaseFrame(frame.frame_id);
 290
 291   rtp_header_.is_key_frame = false;
 292   rtp_header_.is_reference = true;
 293   rtp_header_.reference_frame_id = 0;
 294   rtp_header_.frame_id = 5u;
 295   framer_.InsertPacket(
 296       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 297
 298   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 299   EXPECT_FALSE(next_frame);
 300 }
 301
 302 TEST_F(FramerTest, InOrderReferenceFrameSelection) {
 303   // Create pattern: 0, 1, 4, 5.
 304   transport::EncodedVideoFrame frame;
 305   bool next_frame = false;
 306   bool duplicate = false;
 307
 308   rtp_header_.is_key_frame = true;
 309   rtp_header_.frame_id = 0;
 310   framer_.InsertPacket(
 311       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 312   rtp_header_.is_key_frame = false;
 313   rtp_header_.frame_id = 1;
 314   framer_.InsertPacket(
 315       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 316
 317   // Insert frame #2 partially.
 318   rtp_header_.frame_id = 2;
 319   rtp_header_.max_packet_id = 1;
 320   framer_.InsertPacket(
 321       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 322   rtp_header_.frame_id = 4;
 323   rtp_header_.max_packet_id = 0;
 324   rtp_header_.is_reference = true;
 325   rtp_header_.reference_frame_id = 0;
 326   framer_.InsertPacket(
 327       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 328   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 329   EXPECT_EQ(0u, frame.frame_id);
 330   framer_.ReleaseFrame(frame.frame_id);
 331   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 332   EXPECT_TRUE(next_frame);
 333   EXPECT_EQ(1u, frame.frame_id);
 334   framer_.ReleaseFrame(frame.frame_id);
 335   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 336   EXPECT_FALSE(next_frame);
 337   EXPECT_EQ(4u, frame.frame_id);
 338   framer_.ReleaseFrame(frame.frame_id);
 339   // Insert remaining packet of frame #2 - should no be continuous.
 340   rtp_header_.frame_id = 2;
 341   rtp_header_.packet_id = 1;
 342   framer_.InsertPacket(
 343       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 344   EXPECT_FALSE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 345   rtp_header_.is_reference = false;
 346   rtp_header_.frame_id = 5;
 347   rtp_header_.packet_id = 0;
 348   rtp_header_.max_packet_id = 0;
 349   framer_.InsertPacket(
 350       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 351   EXPECT_TRUE(framer_.GetEncodedVideoFrame(&frame, &next_frame));
 352   EXPECT_TRUE(next_frame);
 353   EXPECT_EQ(5u, frame.frame_id);
 354 }
 355
 356 TEST_F(FramerTest, AudioWrap) {
 357   // All audio frames are marked as key frames.
 358   transport::EncodedAudioFrame frame;
 359   bool next_frame = false;
 360   bool duplicate = false;
 361
 362   rtp_header_.is_key_frame = true;
 363   rtp_header_.frame_id = 254;
 364
 365   framer_.InsertPacket(
 366       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 367   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 368   EXPECT_TRUE(next_frame);
 369   EXPECT_EQ(254u, frame.frame_id);
 370   framer_.ReleaseFrame(frame.frame_id);
 371
 372   rtp_header_.frame_id = 255;
 373   framer_.InsertPacket(
 374       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 375
 376   // Insert wrapped frame - should be continuous.
 377   rtp_header_.frame_id = 256;
 378   framer_.InsertPacket(
 379       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 380
 381   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 382   EXPECT_TRUE(next_frame);
 383   EXPECT_EQ(255u, frame.frame_id);
 384   framer_.ReleaseFrame(frame.frame_id);
 385
 386   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 387   EXPECT_TRUE(next_frame);
 388   EXPECT_EQ(256u, frame.frame_id);
 389   framer_.ReleaseFrame(frame.frame_id);
 390 }
 391
 392 TEST_F(FramerTest, AudioWrapWithMissingFrame) {
 393   // All audio frames are marked as key frames.
 394   transport::EncodedAudioFrame frame;
 395   bool next_frame = false;
 396   bool duplicate = false;
 397
 398   // Insert and get first packet.
 399   rtp_header_.is_key_frame = true;
 400   rtp_header_.frame_id = 253;
 401   framer_.InsertPacket(
 402       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 403   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 404   EXPECT_TRUE(next_frame);
 405   EXPECT_EQ(253u, frame.frame_id);
 406   framer_.ReleaseFrame(frame.frame_id);
 407
 408   // Insert third and fourth packets.
 409   rtp_header_.frame_id = 255;
 410   framer_.InsertPacket(
 411       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 412   rtp_header_.frame_id = 256;
 413   framer_.InsertPacket(
 414       payload_.data(), payload_.size(), rtp_header_, &duplicate);
 415
 416   // Get third and fourth packets.
 417   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 418   EXPECT_FALSE(next_frame);
 419   EXPECT_EQ(255u, frame.frame_id);
 420   framer_.ReleaseFrame(frame.frame_id);
 421   EXPECT_TRUE(framer_.GetEncodedAudioFrame(&frame, &next_frame));
 422   EXPECT_TRUE(next_frame);
 423   EXPECT_EQ(256u, frame.frame_id);
 424   framer_.ReleaseFrame(frame.frame_id);
 425 }
 426
 427 }  // namespace cast
 428 }  // namespace media