Add sender controlled playout delay limits

webrtc/modules/video_coding/jitter_buffer_unittest.cc

 /*
  *  Copyright (c) 2011 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 24 matching lines @@
 
 class Vp9SsMapTest : public ::testing::Test {
  protected:
   Vp9SsMapTest() : packet_(data_, 1400, 1234, 1, true) {}
 
   virtual void SetUp() {
     packet_.isFirstPacket = true;
     packet_.markerBit = true;
     packet_.frameType = kVideoFrameKey;
     packet_.codec = kVideoCodecVP9;
-    packet_.codecSpecificHeader.codec = kRtpVideoVp9;
-    packet_.codecSpecificHeader.codecHeader.VP9.flexible_mode = false;
-    packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 0;
-    packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx = kNoTemporalIdx;
-    packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch = false;
-    packet_.codecSpecificHeader.codecHeader.VP9.ss_data_available = true;
-    packet_.codecSpecificHeader.codecHeader.VP9.gof.SetGofInfoVP9(
+    packet_.video_header.codec = kRtpVideoVp9;
+    packet_.video_header.codecHeader.VP9.flexible_mode = false;
+    packet_.video_header.codecHeader.VP9.gof_idx = 0;
+    packet_.video_header.codecHeader.VP9.temporal_idx = kNoTemporalIdx;
+    packet_.video_header.codecHeader.VP9.temporal_up_switch = false;
+    packet_.video_header.codecHeader.VP9.ss_data_available = true;
+    packet_.video_header.codecHeader.VP9.gof.SetGofInfoVP9(
         kTemporalStructureMode3);  // kTemporalStructureMode3: 0-2-1-2..
   }
 
   Vp9SsMap map_;
   uint8_t data_[1500];
   VCMPacket packet_;
 };
 
 TEST_F(Vp9SsMapTest, Insert) {
   EXPECT_TRUE(map_.Insert(packet_));
 }
 
 TEST_F(Vp9SsMapTest, Insert_NoSsData) {
-  packet_.codecSpecificHeader.codecHeader.VP9.ss_data_available = false;
+  packet_.video_header.codecHeader.VP9.ss_data_available = false;
   EXPECT_FALSE(map_.Insert(packet_));
 }
 
 TEST_F(Vp9SsMapTest, Find) {
   EXPECT_TRUE(map_.Insert(packet_));
   Vp9SsMap::SsMap::iterator it;
   EXPECT_TRUE(map_.Find(packet_.timestamp, &it));
   EXPECT_EQ(packet_.timestamp, it->first);
 }
 
@@ skipping 56 matching lines @@
   packet_.timestamp = kSsTimestamp3;
   EXPECT_TRUE(map_.Insert(packet_));
 
   map_.RemoveOld(kSsTimestamp3);
   EXPECT_FALSE(map_.Find(kSsTimestamp1, &it));
   EXPECT_FALSE(map_.Find(kSsTimestamp2, &it));
   EXPECT_TRUE(map_.Find(kSsTimestamp3, &it));
 }
 
 TEST_F(Vp9SsMapTest, UpdatePacket_NoSsData) {
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 0;
+  packet_.video_header.codecHeader.VP9.gof_idx = 0;
   EXPECT_FALSE(map_.UpdatePacket(&packet_));
 }
 
 TEST_F(Vp9SsMapTest, UpdatePacket_NoGofIdx) {
   EXPECT_TRUE(map_.Insert(packet_));
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = kNoGofIdx;
+  packet_.video_header.codecHeader.VP9.gof_idx = kNoGofIdx;
   EXPECT_FALSE(map_.UpdatePacket(&packet_));
 }
 
 TEST_F(Vp9SsMapTest, UpdatePacket_InvalidGofIdx) {
   EXPECT_TRUE(map_.Insert(packet_));
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 4;
+  packet_.video_header.codecHeader.VP9.gof_idx = 4;
   EXPECT_FALSE(map_.UpdatePacket(&packet_));
 }
 
 TEST_F(Vp9SsMapTest, UpdatePacket) {
   EXPECT_TRUE(map_.Insert(packet_));  // kTemporalStructureMode3: 0-2-1-2..
 
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 0;
+  packet_.video_header.codecHeader.VP9.gof_idx = 0;
   EXPECT_TRUE(map_.UpdatePacket(&packet_));
-  EXPECT_EQ(0, packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx);
-  EXPECT_FALSE(packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch);
-  EXPECT_EQ(1U, packet_.codecSpecificHeader.codecHeader.VP9.num_ref_pics);
-  EXPECT_EQ(4, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
+  EXPECT_EQ(0, packet_.video_header.codecHeader.VP9.temporal_idx);
+  EXPECT_FALSE(packet_.video_header.codecHeader.VP9.temporal_up_switch);
+  EXPECT_EQ(1U, packet_.video_header.codecHeader.VP9.num_ref_pics);
+  EXPECT_EQ(4, packet_.video_header.codecHeader.VP9.pid_diff[0]);
 
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 1;
+  packet_.video_header.codecHeader.VP9.gof_idx = 1;
   EXPECT_TRUE(map_.UpdatePacket(&packet_));
-  EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx);
-  EXPECT_TRUE(packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch);
-  EXPECT_EQ(1U, packet_.codecSpecificHeader.codecHeader.VP9.num_ref_pics);
-  EXPECT_EQ(1, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
+  EXPECT_EQ(2, packet_.video_header.codecHeader.VP9.temporal_idx);
+  EXPECT_TRUE(packet_.video_header.codecHeader.VP9.temporal_up_switch);
+  EXPECT_EQ(1U, packet_.video_header.codecHeader.VP9.num_ref_pics);
+  EXPECT_EQ(1, packet_.video_header.codecHeader.VP9.pid_diff[0]);
 
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 2;
+  packet_.video_header.codecHeader.VP9.gof_idx = 2;
   EXPECT_TRUE(map_.UpdatePacket(&packet_));
-  EXPECT_EQ(1, packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx);
-  EXPECT_TRUE(packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch);
-  EXPECT_EQ(1U, packet_.codecSpecificHeader.codecHeader.VP9.num_ref_pics);
-  EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
+  EXPECT_EQ(1, packet_.video_header.codecHeader.VP9.temporal_idx);
+  EXPECT_TRUE(packet_.video_header.codecHeader.VP9.temporal_up_switch);
+  EXPECT_EQ(1U, packet_.video_header.codecHeader.VP9.num_ref_pics);
+  EXPECT_EQ(2, packet_.video_header.codecHeader.VP9.pid_diff[0]);
 
-  packet_.codecSpecificHeader.codecHeader.VP9.gof_idx = 3;
+  packet_.video_header.codecHeader.VP9.gof_idx = 3;
   EXPECT_TRUE(map_.UpdatePacket(&packet_));
-  EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.temporal_idx);
-  EXPECT_FALSE(packet_.codecSpecificHeader.codecHeader.VP9.temporal_up_switch);
-  EXPECT_EQ(2U, packet_.codecSpecificHeader.codecHeader.VP9.num_ref_pics);
-  EXPECT_EQ(1, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[0]);
-  EXPECT_EQ(2, packet_.codecSpecificHeader.codecHeader.VP9.pid_diff[1]);
+  EXPECT_EQ(2, packet_.video_header.codecHeader.VP9.temporal_idx);
+  EXPECT_FALSE(packet_.video_header.codecHeader.VP9.temporal_up_switch);
+  EXPECT_EQ(2U, packet_.video_header.codecHeader.VP9.num_ref_pics);
+  EXPECT_EQ(1, packet_.video_header.codecHeader.VP9.pid_diff[0]);
+  EXPECT_EQ(2, packet_.video_header.codecHeader.VP9.pid_diff[1]);
 }
 
 class ProcessThreadMock : public ProcessThread {
  public:
   MOCK_METHOD0(Start, void());
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD1(WakeUp, void(Module* module));
   MOCK_METHOD1(RegisterModule, void(Module* module));
   MOCK_METHOD1(DeRegisterModule, void(Module* module));
   void PostTask(std::unique_ptr<rtc::QueuedTask> task) /*override*/ {}
@@ skipping 40 matching lines @@
         data_[i + 2] = 0;
         data_[i + 3] = 0x80;
         count = 3;
         i += 3;
       }
     }
     packet_.reset(new VCMPacket(data_, size_, seq_num_, timestamp_, true));
   }
 
   VCMEncodedFrame* DecodeCompleteFrame() {
-    uint32_t timestamp = 0;
-    bool found_frame = jitter_buffer_->NextCompleteTimestamp(10, &timestamp);
+    VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(10);
     if (!found_frame)
-      return NULL;
-    VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
-    return frame;
+      return nullptr;
+    return jitter_buffer_->ExtractAndSetDecode(found_frame->TimeStamp());
   }
 
   VCMEncodedFrame* DecodeIncompleteFrame() {
     uint32_t timestamp = 0;
     bool found_frame = jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp);
     if (!found_frame)
       return NULL;
     VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
     return frame;
   }
@@ skipping 137 matching lines @@
 
   void DropFrame(int num_packets) {
     stream_generator_->GenerateFrame(kVideoFrameDelta, num_packets, 0,
                                      clock_->TimeInMilliseconds());
     for (int i = 0; i < num_packets; ++i)
       stream_generator_->DropLastPacket();
     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   }
 
   bool DecodeCompleteFrame() {
-    uint32_t timestamp = 0;
-    bool found_frame = jitter_buffer_->NextCompleteTimestamp(0, &timestamp);
+    VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(0);
     if (!found_frame)
       return false;
 
-    VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(timestamp);
+    VCMEncodedFrame* frame =
+        jitter_buffer_->ExtractAndSetDecode(found_frame->TimeStamp());
     bool ret = (frame != NULL);
     jitter_buffer_->ReleaseFrame(frame);
     return ret;
   }
 
   bool DecodeIncompleteFrame() {
     uint32_t timestamp = 0;
     bool found_frame = jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp);
     if (!found_frame)
       return false;
@@ skipping 497 matching lines @@
   //  -------------------------------------------------
   // | 65485 | 65486 | 65487 | 65488 | 65489 | ...
   // | pid:5 | pid:6 | pid:7 | pid:8 | pid:9 | ...
   // | tid:0 | tid:2 | tid:1 | tid:2 | tid:0 | ...
   // |  ss   |   x   |   x   |   x   |       |
   //  -------------------------------------------------
   // |<----------tl0idx:200--------->|<---tl0idx:201---
 
   bool re = false;
   packet_->codec = kVideoCodecVP9;
-  packet_->codecSpecificHeader.codec = kRtpVideoVp9;
+  packet_->video_header.codec = kRtpVideoVp9;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.flexible_mode = false;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.beginning_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.end_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = false;
+  packet_->video_header.codecHeader.VP9.flexible_mode = false;
+  packet_->video_header.codecHeader.VP9.spatial_idx = 0;
+  packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
+  packet_->video_header.codecHeader.VP9.end_of_frame = true;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
 
   packet_->seqNum = 65485;
   packet_->timestamp = 1000;
   packet_->frameType = kVideoFrameKey;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 5;
-  packet_->codecSpecificHeader.codecHeader.VP9.tl0_pic_idx = 200;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.ss_data_available = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.gof.SetGofInfoVP9(
+  packet_->video_header.codecHeader.VP9.picture_id = 5;
+  packet_->video_header.codecHeader.VP9.tl0_pic_idx = 200;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 0;
+  packet_->video_header.codecHeader.VP9.ss_data_available = true;
+  packet_->video_header.codecHeader.VP9.gof.SetGofInfoVP9(
       kTemporalStructureMode3);  // kTemporalStructureMode3: 0-2-1-2..
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   // Insert next temporal layer 0.
   packet_->seqNum = 65489;
   packet_->timestamp = 13000;
   packet_->frameType = kVideoFrameDelta;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 9;
-  packet_->codecSpecificHeader.codecHeader.VP9.tl0_pic_idx = 201;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.ss_data_available = false;
+  packet_->video_header.codecHeader.VP9.picture_id = 9;
+  packet_->video_header.codecHeader.VP9.tl0_pic_idx = 201;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 0;
+  packet_->video_header.codecHeader.VP9.ss_data_available = false;
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(1000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   frame_out = DecodeCompleteFrame();
   EXPECT_EQ(13000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
   // Verify that frames are updated with SS data when SS packet is reordered.
   //  --------------------------------
   // | 65486 | 65487 | 65485 |...
   // | pid:6 | pid:7 | pid:5 |...
   // | tid:2 | tid:1 | tid:0 |...
   // |       |       |  ss   |
   //  --------------------------------
   // |<--------tl0idx:200--------->|
 
   bool re = false;
   packet_->codec = kVideoCodecVP9;
-  packet_->codecSpecificHeader.codec = kRtpVideoVp9;
+  packet_->video_header.codec = kRtpVideoVp9;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.flexible_mode = false;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.beginning_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.end_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.tl0_pic_idx = 200;
+  packet_->video_header.codecHeader.VP9.flexible_mode = false;
+  packet_->video_header.codecHeader.VP9.spatial_idx = 0;
+  packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
+  packet_->video_header.codecHeader.VP9.end_of_frame = true;
+  packet_->video_header.codecHeader.VP9.tl0_pic_idx = 200;
 
   packet_->seqNum = 65486;
   packet_->timestamp = 6000;
   packet_->frameType = kVideoFrameDelta;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 6;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 2;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = true;
+  packet_->video_header.codecHeader.VP9.picture_id = 6;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 2;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   packet_->seqNum = 65487;
   packet_->timestamp = 9000;
   packet_->frameType = kVideoFrameDelta;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 7;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 1;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = true;
+  packet_->video_header.codecHeader.VP9.picture_id = 7;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 1;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   // Insert first frame with SS data.
   packet_->seqNum = 65485;
   packet_->timestamp = 3000;
   packet_->frameType = kVideoFrameKey;
   packet_->width = 352;
   packet_->height = 288;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 5;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = false;
-  packet_->codecSpecificHeader.codecHeader.VP9.ss_data_available = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.gof.SetGofInfoVP9(
+  packet_->video_header.codecHeader.VP9.picture_id = 5;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 0;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
+  packet_->video_header.codecHeader.VP9.ss_data_available = true;
+  packet_->video_header.codecHeader.VP9.gof.SetGofInfoVP9(
       kTemporalStructureMode3);  // kTemporalStructureMode3: 0-2-1-2..
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(3000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
   EXPECT_FALSE(
       frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
   jitter_buffer_->ReleaseFrame(frame_out);
@@ skipping 20 matching lines @@
   // | pid:6  | pid:6  | pid:5  | pid:5  |...
   // | tid:1  | tid:1  | tid:0  | tid:0  |...
   // | sid:0  | sid:1  | sid:1  | sid:0  |...
   // | t:6000 | t:6000 | t:3000 | t:3000 |
   // |        |        |        |  ss    |
   //  -----------------------------------------
   // |<-----------tl0idx:200------------>|
 
   bool re = false;
   packet_->codec = kVideoCodecVP9;
-  packet_->codecSpecificHeader.codec = kRtpVideoVp9;
-  packet_->codecSpecificHeader.codecHeader.VP9.flexible_mode = false;
-  packet_->codecSpecificHeader.codecHeader.VP9.beginning_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.end_of_frame = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.tl0_pic_idx = 200;
+  packet_->video_header.codec = kRtpVideoVp9;
+  packet_->video_header.codecHeader.VP9.flexible_mode = false;
+  packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
+  packet_->video_header.codecHeader.VP9.end_of_frame = true;
+  packet_->video_header.codecHeader.VP9.tl0_pic_idx = 200;
 
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = 65486;
   packet_->timestamp = 6000;
   packet_->frameType = kVideoFrameDelta;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 6;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 1;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = true;
+  packet_->video_header.codecHeader.VP9.spatial_idx = 0;
+  packet_->video_header.codecHeader.VP9.picture_id = 6;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 1;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
 
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = 65487;
   packet_->frameType = kVideoFrameDelta;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 1;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 6;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 1;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = true;
+  packet_->video_header.codecHeader.VP9.spatial_idx = 1;
+  packet_->video_header.codecHeader.VP9.picture_id = 6;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 1;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = true;
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   packet_->isFirstPacket = false;
   packet_->markerBit = true;
   packet_->seqNum = 65485;
   packet_->timestamp = 3000;
   packet_->frameType = kVideoFrameKey;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 1;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 5;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = false;
+  packet_->video_header.codecHeader.VP9.spatial_idx = 1;
+  packet_->video_header.codecHeader.VP9.picture_id = 5;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 0;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
 
   // Insert first frame with SS data.
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = 65484;
   packet_->frameType = kVideoFrameKey;
   packet_->width = 352;
   packet_->height = 288;
-  packet_->codecSpecificHeader.codecHeader.VP9.spatial_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.picture_id = 5;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_idx = 0;
-  packet_->codecSpecificHeader.codecHeader.VP9.temporal_up_switch = false;
-  packet_->codecSpecificHeader.codecHeader.VP9.ss_data_available = true;
-  packet_->codecSpecificHeader.codecHeader.VP9.gof.SetGofInfoVP9(
+  packet_->video_header.codecHeader.VP9.spatial_idx = 0;
+  packet_->video_header.codecHeader.VP9.picture_id = 5;
+  packet_->video_header.codecHeader.VP9.temporal_idx = 0;
+  packet_->video_header.codecHeader.VP9.temporal_up_switch = false;
+  packet_->video_header.codecHeader.VP9.ss_data_available = true;
+  packet_->video_header.codecHeader.VP9.gof.SetGofInfoVP9(
       kTemporalStructureMode2);  // kTemporalStructureMode3: 0-1-0-1..
   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
 
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   EXPECT_EQ(3000U, frame_out->TimeStamp());
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
   EXPECT_FALSE(
       frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
   jitter_buffer_->ReleaseFrame(frame_out);
@@ skipping 45 matching lines @@
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
 
   bool retransmitted = false;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp = 0;
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   packet_->isFirstPacket = false;
   for (int i = 1; i < 9; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-    EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+    EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // last packet
   packet_->markerBit = true;
   packet_->seqNum++;
 
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 10 * size_, false);
   EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame
   packet_->seqNum -= 99;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   packet_->isFirstPacket = false;
   for (int i = 1; i < 8; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kDecodableSession,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-    EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+    EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   packet_->seqNum++;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   frame_out = DecodeIncompleteFrame();
   ASSERT_FALSE(NULL == frame_out);
   CheckOutFrame(frame_out, 9 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 
   packet_->markerBit = true;
   packet_->seqNum++;
@@ skipping 21 matching lines @@
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = false;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp;
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame - an incomplete key frame.
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->seqNum -= 99;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert a few more packets. Make sure we're waiting for the key frame to be
   // complete.
   packet_->isFirstPacket = false;
   for (int i = 1; i < 5; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-    EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+    EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // Complete key frame.
   packet_->markerBit = true;
   packet_->seqNum++;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   frame_out = DecodeCompleteFrame();
   CheckOutFrame(frame_out, 6 * size_, false);
@@ skipping 22 matching lines @@
   // An incomplete frame can only be decoded once a subsequent frame has begun
   // to arrive. Insert packet in distant frame for this purpose.
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = false;
   packet_->markerBit = false;
   packet_->seqNum += 100;
   packet_->timestamp += 33 * 90 * 8;
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t timestamp;
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   // Insert second frame with the first packet missing. Make sure we're waiting
   // for the key frame to be complete.
   packet_->seqNum -= 98;
   packet_->timestamp -= 33 * 90 * 7;
 
   EXPECT_EQ(kIncomplete,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   for (int i = 0; i < 5; ++i) {
     packet_->seqNum++;
     EXPECT_EQ(kIncomplete,
               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-    EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+    EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
     EXPECT_FALSE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
   }
 
   // Add first packet. Frame should now be decodable, but incomplete.
   packet_->isFirstPacket = true;
   packet_->seqNum -= 6;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&timestamp));
 
   frame_out = DecodeIncompleteFrame();
   CheckOutFrame(frame_out, 7 * size_, false);
   EXPECT_EQ(kVideoFrameDelta, frame_out->FrameType());
   jitter_buffer_->ReleaseFrame(frame_out);
 }
 
 TEST_P(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
   // Will use one packet per frame.
   jitter_buffer_->SetDecodeErrorMode(kWithErrors);
   packet_->frameType = kVideoFrameKey;
   packet_->isFirstPacket = true;
   packet_->markerBit = true;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   bool retransmitted = false;
   EXPECT_EQ(kCompleteSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   uint32_t next_timestamp;
-  EXPECT_TRUE(jitter_buffer_->NextCompleteTimestamp(0, &next_timestamp));
-  EXPECT_EQ(packet_->timestamp, next_timestamp);
-  VCMEncodedFrame* frame = jitter_buffer_->ExtractAndSetDecode(next_timestamp);
+  VCMEncodedFrame* frame = jitter_buffer_->NextCompleteFrame(0);
+  EXPECT_NE(frame, nullptr);
+  EXPECT_EQ(packet_->timestamp, frame->TimeStamp());
+  frame = jitter_buffer_->ExtractAndSetDecode(frame->TimeStamp());
   EXPECT_TRUE(frame != NULL);
   jitter_buffer_->ReleaseFrame(frame);
 
   // Drop a complete frame.
   timestamp_ += 2 * 33 * 90;
   seq_num_ += 2;
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
   // Insert a packet (so the previous one will be released).
   timestamp_ += 33 * 90;
   seq_num_ += 2;
   packet_->frameType = kVideoFrameDelta;
   packet_->isFirstPacket = true;
   packet_->markerBit = false;
   packet_->seqNum = seq_num_;
   packet_->timestamp = timestamp_;
   EXPECT_EQ(kDecodableSession,
             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
-  EXPECT_FALSE(jitter_buffer_->NextCompleteTimestamp(0, &next_timestamp));
+  EXPECT_EQ(jitter_buffer_->NextCompleteFrame(0), nullptr);
   EXPECT_TRUE(jitter_buffer_->NextMaybeIncompleteTimestamp(&next_timestamp));
   EXPECT_EQ(packet_->timestamp - 33 * 90, next_timestamp);
 }
 
 TEST_P(TestBasicJitterBuffer, PacketLoss) {
   // Verify missing packets statistics and not decodable packets statistics.
   // Insert 10 frames consisting of 4 packets and remove one from all of them.
   // The last packet is an empty (non-media) packet.
 
   // Select a start seqNum which triggers a difficult wrap situation
@@ skipping 1232 matching lines @@
 
   // Stream should be decodable from this point.
   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
   InsertFrame(kVideoFrameDelta);
   EXPECT_TRUE(DecodeCompleteFrame());
   nack_list = jitter_buffer_->GetNackList(&extended);
   EXPECT_EQ(0u, nack_list.size());
 }
 
 }  // namespace webrtc