Padding is now used to check for continuity in the packet sequence.

webrtc/modules/video_coding/video_packet_buffer_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 11 matching lines @@
 
 namespace webrtc {
 namespace video_coding {
 
 class TestPacketBuffer : public ::testing::Test,
                          public OnCompleteFrameCallback {
  protected:
   TestPacketBuffer()
       : rand_(0x8739211),
         packet_buffer_(new PacketBuffer(kStartSize, kMaxSize, this)),
-        frames_from_callback_(FrameComp()) {}
+        frames_from_callback_(FrameComp()),
+        dummy_data_(new uint8_t[kDummyDataSize]()) {}
 
   uint16_t Rand() { return rand_.Rand(std::numeric_limits<uint16_t>::max()); }
 
   void OnCompleteFrame(std::unique_ptr<FrameObject> frame) override {
     uint16_t pid = frame->picture_id;
     uint16_t sidx = frame->spatial_layer;
     auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx));
     if (frame_it != frames_from_callback_.end()) {
       ADD_FAILURE() << "Already received frame with (pid:sidx): ("
                     << pid << ":" << sidx << ")";
@@ skipping 11 matching lines @@
     frames_from_callback_.clear();
   }
 
   // Short version of true and false.
   enum {
     kT = true,
     kF = false
   };
 
   // Insert a generic packet into the packet buffer.
-  void InsertGeneric(uint16_t seq_num,              // packet sequence number
-                     bool keyframe,                 // is keyframe
-                     bool first,                    // is first packet of frame
-                     bool last,                     // is last packet of frame
-                     size_t data_size = 0,          // size of data
-                     uint8_t* data = nullptr) {     // data pointer
+  void InsertGeneric(uint16_t seq_num,           // packet sequence number
+                     bool keyframe,              // is keyframe
+                     bool first,                 // is first packet of frame
+                     bool last,                  // is last packet of frame
+                     int data_size = -1,         // size of data
+                     uint8_t* data = nullptr) {  // data pointer
+    if (data_size == -1) {
+      data_size = kDummyDataSize;
+      data = dummy_data_.get();
+    }
+
     VCMPacket packet;
     packet.codec = kVideoCodecGeneric;
     packet.seqNum = seq_num;
     packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta;
     packet.isFirstPacket = first;
     packet.markerBit = last;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
 
     EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   }
 
   // Insert a Vp8 packet into the packet buffer.
   void InsertVp8(uint16_t seq_num,              // packet sequence number
                  bool keyframe,                 // is keyframe
                  bool first,                    // is first packet of frame
                  bool last,                     // is last packet of frame
                  bool sync = false,             // is sync frame
                  int32_t pid = kNoPictureId,    // picture id
                  uint8_t tid = kNoTemporalIdx,  // temporal id
                  int32_t tl0 = kNoTl0PicIdx,    // tl0 pic index
-                 size_t data_size = 0,          // size of data
+                 int data_size = -1,            // size of data
                  uint8_t* data = nullptr) {     // data pointer
+    if (data_size == -1) {
+      data_size = kDummyDataSize;
+      data = dummy_data_.get();
+    }
+
     VCMPacket packet;
     packet.codec = kVideoCodecVP8;
     packet.seqNum = seq_num;
     packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta;
     packet.isFirstPacket = first;
     packet.markerBit = last;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
     packet.video_header.codecHeader.VP8.pictureId = pid % (1 << 15);
     packet.video_header.codecHeader.VP8.temporalIdx = tid;
     packet.video_header.codecHeader.VP8.tl0PicIdx = tl0;
     packet.video_header.codecHeader.VP8.layerSync = sync;
 
     EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   }
 
   // Insert a Vp9 packet into the packet buffer.
   void InsertVp9Gof(uint16_t seq_num,              // packet sequence number
                     bool keyframe,                 // is keyframe
                     bool first,                    // is first packet of frame
                     bool last,                     // is last packet of frame
                     bool up = false,               // frame is up-switch point
                     int32_t pid = kNoPictureId,    // picture id
                     uint8_t sid = kNoSpatialIdx,   // spatial id
                     uint8_t tid = kNoTemporalIdx,  // temporal id
                     int32_t tl0 = kNoTl0PicIdx,    // tl0 pic index
                     GofInfoVP9* ss = nullptr,      // scalability structure
-                    size_t data_size = 0,          // size of data
+                    int data_size = -1,            // size of data
                     uint8_t* data = nullptr) {     // data pointer
+    if (data_size == -1) {
+      data_size = kDummyDataSize;
+      data = dummy_data_.get();
+    }
+
     VCMPacket packet;
     packet.codec = kVideoCodecVP9;
     packet.seqNum = seq_num;
     packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta;
     packet.isFirstPacket = first;
     packet.markerBit = last;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
     packet.video_header.codecHeader.VP9.flexible_mode = false;
     packet.video_header.codecHeader.VP9.picture_id = pid % (1 << 15);
     packet.video_header.codecHeader.VP9.temporal_idx = tid;
     packet.video_header.codecHeader.VP9.spatial_idx = sid;
     packet.video_header.codecHeader.VP9.tl0_pic_idx = tl0;
     packet.video_header.codecHeader.VP9.temporal_up_switch = up;
     if (ss != nullptr) {
       packet.video_header.codecHeader.VP9.ss_data_available = true;
       packet.video_header.codecHeader.VP9.gof = *ss;
     }
 
     EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   }
 
   // Insert a Vp9 packet into the packet buffer.
-  void InsertVp9Flex(uint16_t seq_num,              // packet sequence number
-                     bool keyframe,                 // is keyframe
-                     bool first,                    // is first packet of frame
-                     bool last,                     // is last packet of frame
-                     bool inter,                    // depends on S-1 layer
-                     int32_t pid = kNoPictureId,    // picture id
-                     uint8_t sid = kNoSpatialIdx,   // spatial id
-                     uint8_t tid = kNoTemporalIdx,  // temporal id
-                     int32_t tl0 = kNoTl0PicIdx,    // tl0 pic index
-                     std::vector<uint8_t> refs =
-                       std::vector<uint8_t>(),      // frame references
-                     size_t data_size = 0,          // size of data
-                     uint8_t* data = nullptr) {     // data pointer
+  void InsertVp9Flex(
+      uint16_t seq_num,              // packet sequence number
+      bool keyframe,                 // is keyframe
+      bool first,                    // is first packet of frame
+      bool last,                     // is last packet of frame
+      bool inter,                    // depends on S-1 layer
+      int32_t pid = kNoPictureId,    // picture id
+      uint8_t sid = kNoSpatialIdx,   // spatial id
+      uint8_t tid = kNoTemporalIdx,  // temporal id
+      int32_t tl0 = kNoTl0PicIdx,    // tl0 pic index
+      std::vector<uint8_t> refs = std::vector<uint8_t>(),  // frame references
+      int data_size = -1,                                  // size of data
+      uint8_t* data = nullptr) {                           // data pointer
+    if (data_size == -1) {
+      data_size = kDummyDataSize;
+      data = dummy_data_.get();
+    }
+
     VCMPacket packet;
     packet.codec = kVideoCodecVP9;
     packet.seqNum = seq_num;
     packet.frameType = keyframe ? kVideoFrameKey : kVideoFrameDelta;
     packet.isFirstPacket = first;
     packet.markerBit = last;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
     packet.video_header.codecHeader.VP9.inter_layer_predicted = inter;
     packet.video_header.codecHeader.VP9.flexible_mode = true;
@@ skipping 49 matching lines @@
   template <typename... T>
   void RefsToSet(std::set<uint16_t>* m, uint16_t ref, T... refs) const {
     m->insert(ref);
     RefsToSet(m, refs...);
   }
 
   void RefsToSet(std::set<uint16_t>* m) const {}
 
   const int kStartSize = 16;
   const int kMaxSize = 64;
+  const int kDummyDataSize = 4;
 
   Random rand_;
   std::unique_ptr<PacketBuffer> packet_buffer_;
   struct FrameComp {
     bool operator()(const std::pair<uint16_t, uint8_t> f1,
                     const std::pair<uint16_t, uint8_t> f2) const {
                       if (f1.first == f2.first)
                         return f1.second < f2.second;
                       return f1.first < f2.first;
                     }
   };
   std::map<std::pair<uint16_t, uint8_t>,
            std::unique_ptr<FrameObject>,
            FrameComp> frames_from_callback_;
+
+  std::unique_ptr<uint8_t[]> dummy_data_;
 };
 
 TEST_F(TestPacketBuffer, InsertOnePacket) {
   VCMPacket packet;
   packet.seqNum = Rand();
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
 }
 
 TEST_F(TestPacketBuffer, InsertMultiplePackets) {
   VCMPacket packet;
@@ skipping 16 matching lines @@
 
 TEST_F(TestPacketBuffer, NackCount) {
   uint16_t seq_num = Rand();
 
   VCMPacket packet;
   packet.codec = kVideoCodecGeneric;
   packet.seqNum = seq_num;
   packet.frameType = kVideoFrameKey;
   packet.isFirstPacket = true;
   packet.markerBit = false;
-  packet.sizeBytes = 0;
-  packet.dataPtr = nullptr;
+  packet.dataPtr = dummy_data_.get();
+  packet.sizeBytes = kDummyDataSize;
   packet.timesNacked = 0;
 
   packet_buffer_->InsertPacket(packet);
 
   packet.seqNum++;
   packet.isFirstPacket = false;
   packet.timesNacked = 1;
   packet_buffer_->InsertPacket(packet);
 
   packet.seqNum++;
@@ skipping 82 matching lines @@
   InsertGeneric(seq_num    , kT, kT  , kF);
   InsertGeneric(seq_num + 2, kT, kF  , kT);
   InsertGeneric(seq_num + 1, kT, kF  , kF);
 
   EXPECT_EQ(1UL, frames_from_callback_.size());
 }
 
 TEST_F(TestPacketBuffer, DiscardOldPacket) {
   uint16_t seq_num = Rand();
   VCMPacket packet;
+  packet.dataPtr = dummy_data_.get();
+  packet.sizeBytes = kDummyDataSize;
   packet.seqNum = Rand();
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   packet.seqNum += 2;
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
 
   for (int i = 3; i < kMaxSize; ++i) {
     ++packet.seqNum;
     EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   }
 
   ++packet.seqNum;
   EXPECT_FALSE(packet_buffer_->InsertPacket(packet));
   packet_buffer_->ClearTo(seq_num + 1);
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
 }
 
 TEST_F(TestPacketBuffer, DiscardMultipleOldPackets) {
   uint16_t seq_num = Rand();
   VCMPacket packet;
+  packet.dataPtr = dummy_data_.get();
+  packet.sizeBytes = kDummyDataSize;
   packet.seqNum = seq_num;
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   packet.seqNum += 2;
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
 
   for (int i = 3; i < kMaxSize; ++i) {
     ++packet.seqNum;
     EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   }
 
@@ skipping 55 matching lines @@
   //            seq_num    , kf, frst, lst, data_size        , data
   InsertGeneric(seq_num    , kT, kT  , kF , sizeof(many)     , many);
   InsertGeneric(seq_num + 1, kF, kF  , kF , sizeof(bitstream), bitstream);
   InsertGeneric(seq_num + 2, kF, kF  , kF , sizeof(such)     , such);
   InsertGeneric(seq_num + 3, kF, kF  , kT , sizeof(data)     , data);
 
   ASSERT_EQ(1UL, frames_from_callback_.size());
   CheckReferencesVp8(seq_num + 3);
   EXPECT_TRUE(frames_from_callback_[std::make_pair(seq_num + 3, 0)]->
                                                           GetBitstream(result));
-  EXPECT_EQ(std::strcmp("many bitstream, such data",
-            reinterpret_cast<char*>(result)),
-            0);
+  EXPECT_EQ(memcmp(result, "many bitstream, such data", sizeof(result)), 0);
 }
 
 TEST_F(TestPacketBuffer, FreeSlotsOnFrameDestruction) {
   uint16_t seq_num = Rand();
 
   //            seq_num    , kf, frst, lst
   InsertGeneric(seq_num    , kT, kT  , kF);
   InsertGeneric(seq_num + 1, kF, kF  , kF);
   InsertGeneric(seq_num + 2, kF, kF  , kT);
   EXPECT_EQ(1UL, frames_from_callback_.size());
@@ skipping 20 matching lines @@
 
   //            seq_num                 , kf, frst, lst
   InsertGeneric(seq_num + kStartSize    , kT, kT  , kF);
   InsertGeneric(seq_num + kStartSize + 1, kF, kF  , kF);
   InsertGeneric(seq_num + kStartSize + 2, kF, kF  , kT);
   EXPECT_EQ(2UL, frames_from_callback_.size());
 }
 
 TEST_F(TestPacketBuffer, InvalidateFrameByClearing) {
   VCMPacket packet;
+  packet.dataPtr = dummy_data_.get();
+  packet.sizeBytes = kDummyDataSize;
   packet.codec = kVideoCodecGeneric;
   packet.frameType = kVideoFrameKey;
   packet.isFirstPacket = kT;
   packet.markerBit = kT;
   packet.seqNum = Rand();
   EXPECT_TRUE(packet_buffer_->InsertPacket(packet));
   ASSERT_EQ(1UL, frames_from_callback_.size());
 
   packet_buffer_->Clear();
   EXPECT_FALSE(frames_from_callback_.begin()->second->GetBitstream(nullptr));
 }
 
+TEST_F(TestPacketBuffer, PaddingPackets) {
+  uint16_t seq_num = Rand();
+
+  //            seq_num    , kf, frst, lst
+  InsertGeneric(seq_num    , kT, kT  , kT);
+  InsertGeneric(seq_num + 1, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 3, kF, kT  , kT);
+  EXPECT_EQ(1UL, frames_from_callback_.size());
+  InsertGeneric(seq_num + 2, kF, kF  , kF, 0, nullptr);
+  EXPECT_EQ(2UL, frames_from_callback_.size());
+}
+
+TEST_F(TestPacketBuffer, PaddingPacketsReordered) {
+  uint16_t seq_num = Rand();
+
+  //            seq_num    , kf, frst, lst
+  InsertGeneric(seq_num    , kT, kT  , kT);
+  InsertGeneric(seq_num + 1, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 2, kF, kT  , kF);
+  InsertGeneric(seq_num + 4, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 3, kF, kF  , kT);
+  EXPECT_EQ(2UL, frames_from_callback_.size());
+  CheckReferencesGeneric(seq_num);
+  CheckReferencesGeneric(seq_num + 3, seq_num);
+}
+
+TEST_F(TestPacketBuffer, PaddingPacketsReorderedMultipleKeyframes) {
+  uint16_t seq_num = Rand();
+
+  //            seq_num    , kf, frst, lst
+  InsertGeneric(seq_num    , kT, kT  , kT);
+  InsertGeneric(seq_num + 2, kF, kT  , kF);
+  InsertGeneric(seq_num + 1, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 4, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 5, kT, kT  , kT);
+  InsertGeneric(seq_num + 3, kF, kF  , kT);
+  InsertGeneric(seq_num + 6, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 9, kF, kF  , kF, 0, nullptr);
+  InsertGeneric(seq_num + 8, kF, kF  , kT);
+  InsertGeneric(seq_num + 7, kF, kT  , kF);
+  EXPECT_EQ(4UL, frames_from_callback_.size());
+}
+
 TEST_F(TestPacketBuffer, Vp8NoPictureId) {
   uint16_t seq_num = Rand();
 
   //        seq_num     , kf, frst, lst
   InsertVp8(seq_num     , kT, kT  , kF);
   InsertVp8(seq_num + 1 , kF, kF  , kF);
   InsertVp8(seq_num + 2 , kF, kF  , kT);
   ASSERT_EQ(1UL, frames_from_callback_.size());
 
   InsertVp8(seq_num + 3 , kF, kT  , kF);
@@ skipping 908 matching lines @@
   CheckReferencesVp9(pid + 5, 1, pid + 4);
   CheckReferencesVp9(pid + 6, 0, pid + 4);
   CheckReferencesVp9(pid + 6, 1, pid + 5);
   CheckReferencesVp9(pid + 7, 1, pid + 6);
   CheckReferencesVp9(pid + 8, 0, pid + 6);
   CheckReferencesVp9(pid + 8, 1, pid + 7);
 }
 
 }  // namespace video_coding
 }  // namespace webrtc