Only create H264 frames if there are no gaps in the packet sequence number.

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.
  */
 
 #include <cstring>
 #include <map>
 #include <set>
 #include <utility>
 
 #include "webrtc/base/random.h"
+#include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/packet_buffer.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace video_coding {
 
 class TestPacketBuffer : public ::testing::Test,
                          public OnReceivedFrameCallback {
  protected:
   TestPacketBuffer()
       : rand_(0x7732213),
         clock_(new SimulatedClock(0)),
         packet_buffer_(
             PacketBuffer::Create(clock_.get(), kStartSize, kMaxSize, this)) {}
 
   uint16_t Rand() { return rand_.Rand<uint16_t>(); }
 
   void OnReceivedFrame(std::unique_ptr<RtpFrameObject> frame) override {
     uint16_t first_seq_num = frame->first_seq_num();
     if (frames_from_callback_.find(first_seq_num) !=
         frames_from_callback_.end()) {
       ADD_FAILURE() << "Already received frame with first sequence number "
                     << first_seq_num << ".";
       return;
     }
+
     frames_from_callback_.insert(
         std::make_pair(frame->first_seq_num(), std::move(frame)));
   }
 
   enum IsKeyFrame { kKeyFrame, kDeltaFrame };
   enum IsFirst { kFirst, kNotFirst };
   enum IsLast { kLast, kNotLast };
 
   bool Insert(uint16_t seq_num,           // packet sequence number
               IsKeyFrame keyframe,        // is keyframe
               IsFirst first,              // is first packet of frame
               IsLast last,                // is last packet of frame
               int data_size = 0,          // size of data
               uint8_t* data = nullptr) {  // data pointer
     VCMPacket packet;
     packet.codec = kVideoCodecGeneric;
     packet.seqNum = seq_num;
     packet.frameType =
         keyframe == kKeyFrame ? kVideoFrameKey : kVideoFrameDelta;
     packet.is_first_packet_in_frame = first == kFirst;
     packet.markerBit = last == kLast;
     packet.sizeBytes = data_size;
     packet.dataPtr = data;
 
     return packet_buffer_->InsertPacket(&packet);
   }
 
+  bool InsertH264(uint16_t seq_num,           // packet sequence number
+                  IsKeyFrame keyframe,        // is keyframe
+                  IsFirst first,              // is first packet of frame
+                  IsLast last,                // is last packet of frame
+                  uint32_t timestamp,         // rtp timestamp
+                  int data_size = 0,          // size of data
+                  uint8_t* data = nullptr) {  // data pointer
+    VCMPacket packet;
+    packet.codec = kVideoCodecH264;
+    packet.seqNum = seq_num;
+    packet.timestamp = timestamp;
+    packet.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
+    packet.video_header.codecHeader.H264.nalus_length = keyframe == kKeyFrame;
+    packet.is_first_packet_in_frame = first == kFirst;
+    packet.markerBit = last == kLast;
+    packet.sizeBytes = data_size;
+    packet.dataPtr = data;
+
+    return packet_buffer_->InsertPacket(&packet);
+  }
+
   void CheckFrame(uint16_t first_seq_num) {
     auto frame_it = frames_from_callback_.find(first_seq_num);
     ASSERT_FALSE(frame_it == frames_from_callback_.end())
         << "Could not find frame with first sequence number " << first_seq_num
         << ".";
   }
 
   const int kStartSize = 16;
   const int kMaxSize = 64;
 
@@ skipping 278 matching lines @@
   uint16_t seq_num = Rand();
   uint8_t data_data[] = "some plain old data";
   uint8_t* data = new uint8_t[sizeof(data_data)];
   memcpy(data, data_data, sizeof(data_data));
 
   // EncodedImage::kBufferPaddingBytesH264 is unknown at compile time.
   std::unique_ptr<uint8_t[]> result(
       new uint8_t[sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264]);
 
   VCMPacket packet;
+  packet.video_header.codecHeader.H264.nalus_length = 1;
+  packet.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
   packet.seqNum = seq_num;
   packet.codec = kVideoCodecH264;
   packet.insertStartCode = true;
   packet.video_header.codecHeader.H264.packetization_type = kH264SingleNalu;
   packet.dataPtr = data;
   packet.sizeBytes = sizeof(data_data);
   packet.is_first_packet_in_frame = true;
   packet.markerBit = true;
   packet_buffer_->InsertPacket(&packet);
 
@@ skipping 92 matching lines @@
 
 TEST_F(TestPacketBuffer, ContinuousSeqNumDoubleMarkerBit) {
   Insert(2, kKeyFrame, kNotFirst, kNotLast);
   Insert(1, kKeyFrame, kFirst, kLast);
   frames_from_callback_.clear();
   Insert(3, kKeyFrame, kNotFirst, kLast);
 
   EXPECT_EQ(0UL, frames_from_callback_.size());
 }
 
-TEST_F(TestPacketBuffer, OneH264FrameFillBuffer) {
-  VCMPacket packet;
-  packet.seqNum = 0;
-  packet.codec = kVideoCodecH264;
-  packet.dataPtr = nullptr;
-  packet.sizeBytes = 0;
-  packet.is_first_packet_in_frame = true;
-  packet.markerBit = false;
-  packet_buffer_->InsertPacket(&packet);
-
-  packet.is_first_packet_in_frame = false;
-  for (int i = 1; i < kStartSize - 1; ++i) {
-    packet.seqNum = i;
-    packet_buffer_->InsertPacket(&packet);
-  }
-
-  packet.seqNum = kStartSize - 1;
-  packet.markerBit = true;
-  packet_buffer_->InsertPacket(&packet);
-
-  EXPECT_EQ(1UL, frames_from_callback_.size());
-  CheckFrame(0);
-}
-
-TEST_F(TestPacketBuffer, OneH264FrameMaxSeqNum) {
-  VCMPacket packet;
-  packet.seqNum = 65534;
-  packet.codec = kVideoCodecH264;
-  packet.dataPtr = nullptr;
-  packet.sizeBytes = 0;
-  packet.is_first_packet_in_frame = true;
-  packet.markerBit = false;
-  packet_buffer_->InsertPacket(&packet);
-
-  packet.is_first_packet_in_frame = false;
-  packet.seqNum = 65535;
-  packet.markerBit = true;
-  packet_buffer_->InsertPacket(&packet);
-
-  EXPECT_EQ(1UL, frames_from_callback_.size());
-  CheckFrame(65534);
-}
-
 TEST_F(TestPacketBuffer, PacketTimestamps) {
   rtc::Optional<int64_t> packet_ms;
   rtc::Optional<int64_t> packet_keyframe_ms;
 
   packet_ms = packet_buffer_->LastReceivedPacketMs();
   packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
   EXPECT_FALSE(packet_ms);
   EXPECT_FALSE(packet_keyframe_ms);
 
   int64_t keyframe_ms = clock_->TimeInMilliseconds();
@@ skipping 15 matching lines @@
   EXPECT_EQ(delta_ms, *packet_ms);
   EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
 
   packet_buffer_->Clear();
   packet_ms = packet_buffer_->LastReceivedPacketMs();
   packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
   EXPECT_FALSE(packet_ms);
   EXPECT_FALSE(packet_keyframe_ms);
 }
 
+TEST_F(TestPacketBuffer, OneFrameFillBufferH264) {
+  InsertH264(0, kKeyFrame, kFirst, kNotLast, 1000);
+  for (int i = 1; i < kStartSize - 1; ++i)
+    InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1000);
+  InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1000);
+
+  EXPECT_EQ(1UL, frames_from_callback_.size());
+  CheckFrame(0);
+}
+
+TEST_F(TestPacketBuffer, OneFrameMaxSeqNumH264) {
+  InsertH264(65534, kKeyFrame, kFirst, kNotLast, 1000);
+  InsertH264(65535, kKeyFrame, kNotFirst, kLast, 1000);
+
+  EXPECT_EQ(1UL, frames_from_callback_.size());
+  CheckFrame(65534);
+}
+
+TEST_F(TestPacketBuffer, ClearMissingPacketsOnKeyframeH264) {
+  InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
+  InsertH264(2, kKeyFrame, kFirst, kLast, 3000);
+  InsertH264(3, kDeltaFrame, kFirst, kNotLast, 4000);
+  InsertH264(4, kDeltaFrame, kNotFirst, kLast, 4000);
+
+  ASSERT_EQ(3UL, frames_from_callback_.size());
+
+  InsertH264(kStartSize + 1, kKeyFrame, kFirst, kLast, 18000);
+
+  ASSERT_EQ(4UL, frames_from_callback_.size());
+  CheckFrame(0);
+  CheckFrame(2);
+  CheckFrame(3);
+  CheckFrame(kStartSize + 1);
+}
+
+TEST_F(TestPacketBuffer, FindFramesOnPaddingH264) {
+  InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
+  InsertH264(2, kDeltaFrame, kFirst, kLast, 1000);
+
+  ASSERT_EQ(1UL, frames_from_callback_.size());
+  packet_buffer_->PaddingReceived(1);
+  ASSERT_EQ(2UL, frames_from_callback_.size());
+  CheckFrame(0);
+  CheckFrame(2);
+}
+
 }  // namespace video_coding
 }  // namespace webrtc