Add sender controlled playout delay limits

webrtc/modules/video_coding/jitter_buffer.cc

 /*
  *  Copyright (c) 2012 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 "webrtc/modules/video_coding/jitter_buffer.h"
@@ skipping 106 matching lines @@
 
 void FrameList::Reset(UnorderedFrameList* free_frames) {
   while (!empty()) {
     begin()->second->Reset();
     free_frames->push_back(begin()->second);
     erase(begin());
   }
 }
 
 bool Vp9SsMap::Insert(const VCMPacket& packet) {
-  if (!packet.codecSpecificHeader.codecHeader.VP9.ss_data_available)
+  if (!packet.video_header.codecHeader.VP9.ss_data_available)
     return false;
 
-  ss_map_[packet.timestamp] = packet.codecSpecificHeader.codecHeader.VP9.gof;
+  ss_map_[packet.timestamp] = packet.video_header.codecHeader.VP9.gof;
   return true;
 }
 
 void Vp9SsMap::Reset() {
   ss_map_.clear();
 }
 
 bool Vp9SsMap::Find(uint32_t timestamp, SsMap::iterator* it_out) {
   bool found = false;
   for (SsMap::iterator it = ss_map_.begin(); it != ss_map_.end(); ++it) {
@@ skipping 27 matching lines @@
 
 void Vp9SsMap::AdvanceFront(uint32_t timestamp) {
   RTC_DCHECK(!ss_map_.empty());
   GofInfoVP9 gof = ss_map_.begin()->second;
   ss_map_.erase(ss_map_.begin());
   ss_map_[timestamp] = gof;
 }
 
 // TODO(asapersson): Update according to updates in RTP payload profile.
 bool Vp9SsMap::UpdatePacket(VCMPacket* packet) {
-  uint8_t gof_idx = packet->codecSpecificHeader.codecHeader.VP9.gof_idx;
+  uint8_t gof_idx = packet->video_header.codecHeader.VP9.gof_idx;
   if (gof_idx == kNoGofIdx)
     return false;  // No update needed.
 
   SsMap::iterator it;
   if (!Find(packet->timestamp, &it))
     return false;  // Corresponding SS not yet received.
 
   if (gof_idx >= it->second.num_frames_in_gof)
     return false;  // Assume corresponding SS not yet received.
 
-  RTPVideoHeaderVP9* vp9 = &packet->codecSpecificHeader.codecHeader.VP9;
+  RTPVideoHeaderVP9* vp9 = &packet->video_header.codecHeader.VP9;
   vp9->temporal_idx = it->second.temporal_idx[gof_idx];
   vp9->temporal_up_switch = it->second.temporal_up_switch[gof_idx];
 
   // TODO(asapersson): Set vp9.ref_picture_id[i] and add usage.
   vp9->num_ref_pics = it->second.num_ref_pics[gof_idx];
   for (uint8_t i = 0; i < it->second.num_ref_pics[gof_idx]; ++i) {
     vp9->pid_diff[i] = it->second.pid_diff[gof_idx][i];
   }
   return true;
 }
@@ skipping 290 matching lines @@
     }
   } else if (incomplete_frames_.size() <= 1) {
     // Frame not ready to be decoded.
     return true;
   }
   return false;
 }
 
 // Returns immediately or a |max_wait_time_ms| ms event hang waiting for a
 // complete frame, |max_wait_time_ms| decided by caller.
-bool VCMJitterBuffer::NextCompleteTimestamp(uint32_t max_wait_time_ms,
-                                            uint32_t* timestamp) {
+VCMEncodedFrame* VCMJitterBuffer::NextCompleteFrame(uint32_t max_wait_time_ms) {
   crit_sect_->Enter();
   if (!running_) {
     crit_sect_->Leave();
-    return false;
+    return nullptr;
   }
   CleanUpOldOrEmptyFrames();
 
   if (decodable_frames_.empty() ||
       decodable_frames_.Front()->GetState() != kStateComplete) {
     const int64_t end_wait_time_ms =
         clock_->TimeInMilliseconds() + max_wait_time_ms;
     int64_t wait_time_ms = max_wait_time_ms;
     while (wait_time_ms > 0) {
       crit_sect_->Leave();
       const EventTypeWrapper ret =
           frame_event_->Wait(static_cast<uint32_t>(wait_time_ms));
       crit_sect_->Enter();
       if (ret == kEventSignaled) {
         // Are we shutting down the jitter buffer?
         if (!running_) {
           crit_sect_->Leave();
-          return false;
+          return nullptr;
         }
         // Finding oldest frame ready for decoder.
         CleanUpOldOrEmptyFrames();
         if (decodable_frames_.empty() ||
             decodable_frames_.Front()->GetState() != kStateComplete) {
           wait_time_ms = end_wait_time_ms - clock_->TimeInMilliseconds();
         } else {
           break;
         }
       } else {
         break;
       }
     }
   }
   if (decodable_frames_.empty() ||
       decodable_frames_.Front()->GetState() != kStateComplete) {
     crit_sect_->Leave();
-    return false;
+    return nullptr;
   }
-  *timestamp = decodable_frames_.Front()->TimeStamp();
+  VCMEncodedFrame* encoded_frame = decodable_frames_.Front();
   crit_sect_->Leave();
-  return true;
+  return encoded_frame;
 }
 
 bool VCMJitterBuffer::NextMaybeIncompleteTimestamp(uint32_t* timestamp) {
   CriticalSectionScoped cs(crit_sect_);
   if (!running_) {
     return false;
   }
   if (decode_error_mode_ == kNoErrors) {
     // No point to continue, as we are not decoding with errors.
     return false;
@@ skipping 825 matching lines @@
   if (nack_module_)
     return nack_module_->TimeUntilNextProcess();
   return std::numeric_limits<int64_t>::max();
 }
 
 void VCMJitterBuffer::Process() {
   if (nack_module_)
     nack_module_->Process();
 }
 }  // namespace webrtc