Reland of Fix off-by-one bugs in PacketBuffer when the buffer is filled with a single frame.

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 80 matching lines @@
     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;
+  static constexpr int kStartSize = 16;
+  static constexpr int kMaxSize = 64;
 
   Random rand_;
   std::unique_ptr<SimulatedClock> clock_;
   rtc::scoped_refptr<PacketBuffer> packet_buffer_;
   std::map<uint16_t, std::unique_ptr<RtpFrameObject>> frames_from_callback_;
 };
 
 TEST_F(TestPacketBuffer, InsertOnePacket) {
   const uint16_t seq_num = Rand();
   EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
@@ skipping 278 matching lines @@
       Insert(seq_num, kKeyFrame, kFirst, kNotLast, sizeof(many_data), many));
   EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast,
                      sizeof(bitstream_data), bitstream));
   EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kNotLast,
                      sizeof(such_data), such));
   EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kNotFirst, kLast,
                      sizeof(data_data), data));
 
   ASSERT_EQ(1UL, frames_from_callback_.size());
   CheckFrame(seq_num);
+  EXPECT_EQ(frames_from_callback_[seq_num]->size(), sizeof(result));
   EXPECT_TRUE(frames_from_callback_[seq_num]->GetBitstream(result));
   EXPECT_EQ(memcmp(result, "many bitstream, such data", sizeof(result)), 0);
 }
 
+TEST_F(TestPacketBuffer, GetBitstreamOneFrameOnePacket) {
+  uint8_t bitstream_data[] = "All the bitstream data for this frame!";
+  uint8_t result[sizeof(bitstream_data)];
+  uint8_t* data = new uint8_t[sizeof(bitstream_data)];
+  memcpy(data, bitstream_data, sizeof(bitstream_data));
+
+  EXPECT_TRUE(
+      Insert(0, kKeyFrame, kFirst, kLast, sizeof(bitstream_data), data));
+
+  ASSERT_EQ(1UL, frames_from_callback_.size());
+  CheckFrame(0);
+  EXPECT_EQ(frames_from_callback_[0]->size(), sizeof(bitstream_data));
+  EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
+  EXPECT_EQ(memcmp(result, data, sizeof(bitstream_data)), 0);
+}
+
+TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBuffer) {
+  uint8_t* data_arr[kStartSize];
+  uint8_t expected[kStartSize];
+  uint8_t result[kStartSize];
+
+  for (uint8_t i = 0; i < kStartSize; ++i) {
+    data_arr[i] = new uint8_t[1];
+    data_arr[i][0] = i;
+    expected[i] = i;
+  }
+
+  EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kNotLast, 1, data_arr[0]));
+  for (uint8_t i = 1; i < kStartSize - 1; ++i)
+    EXPECT_TRUE(Insert(i, kKeyFrame, kNotFirst, kNotLast, 1, data_arr[i]));
+  EXPECT_TRUE(Insert(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1,
+                     data_arr[kStartSize - 1]));
+
+  ASSERT_EQ(1UL, frames_from_callback_.size());
+  CheckFrame(0);
+  EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
+  EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
+  EXPECT_EQ(memcmp(result, expected, kStartSize), 0);
+}
+
+TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBufferH264) {
+  uint8_t* data_arr[kStartSize];
+  uint8_t expected[kStartSize];
+  uint8_t result[kStartSize];
+
+  for (uint8_t i = 0; i < kStartSize; ++i) {
+    data_arr[i] = new uint8_t[1];
+    data_arr[i][0] = i;
+    expected[i] = i;
+  }
+
+  EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kNotLast, 1, 1, data_arr[0]));
+  for (uint8_t i = 1; i < kStartSize - 1; ++i) {
+    EXPECT_TRUE(
+        InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1, 1, data_arr[i]));
+  }
+  EXPECT_TRUE(InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, 1,
+                         data_arr[kStartSize - 1]));
+
+  ASSERT_EQ(1UL, frames_from_callback_.size());
+  CheckFrame(0);
+  EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
+  EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
+  EXPECT_EQ(memcmp(result, expected, kStartSize), 0);
+}
+
 TEST_F(TestPacketBuffer, GetBitstreamH264BufferPadding) {
   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]);
 
@@ skipping 150 matching lines @@
 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, CreateFramesAfterFilledBufferH264) {
+  InsertH264(kStartSize - 2, kKeyFrame, kFirst, kLast, 0);
+  ASSERT_EQ(1UL, frames_from_callback_.size());
+  frames_from_callback_.clear();
+
+  InsertH264(kStartSize, kDeltaFrame, kFirst, kNotLast, 2000);
+  for (int i = 1; i < kStartSize; ++i)
+    InsertH264(kStartSize + i, kDeltaFrame, kNotFirst, kNotLast, 2000);
+  InsertH264(kStartSize + kStartSize, kDeltaFrame, kNotFirst, kLast, 2000);
+  ASSERT_EQ(0UL, frames_from_callback_.size());
+
+  InsertH264(kStartSize - 1, kKeyFrame, kFirst, kLast, 1000);
+  ASSERT_EQ(2UL, frames_from_callback_.size());
+  CheckFrame(kStartSize - 1);
+  CheckFrame(kStartSize);
+}
+
 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);
@@ skipping 18 matching lines @@
 
   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