Add sender controlled playout delay limits

webrtc/modules/video_coding/session_info.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.
  */
 
@@ skipping 42 matching lines @@
   if (packets_.empty())
     return empty_seq_num_high_;
   if (empty_seq_num_high_ == -1)
     return packets_.back().seqNum;
   return LatestSequenceNumber(packets_.back().seqNum, empty_seq_num_high_);
 }
 
 int VCMSessionInfo::PictureId() const {
   if (packets_.empty())
     return kNoPictureId;
-  if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp8) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP8.pictureId;
-  } else if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp9) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP9.picture_id;
+  if (packets_.front().video_header.codec == kRtpVideoVp8) {
+    return packets_.front().video_header.codecHeader.VP8.pictureId;
+  } else if (packets_.front().video_header.codec == kRtpVideoVp9) {
+    return packets_.front().video_header.codecHeader.VP9.picture_id;
   } else {
     return kNoPictureId;
   }
 }
 
 int VCMSessionInfo::TemporalId() const {
   if (packets_.empty())
     return kNoTemporalIdx;
-  if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp8) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP8.temporalIdx;
-  } else if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp9) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP9.temporal_idx;
+  if (packets_.front().video_header.codec == kRtpVideoVp8) {
+    return packets_.front().video_header.codecHeader.VP8.temporalIdx;
+  } else if (packets_.front().video_header.codec == kRtpVideoVp9) {
+    return packets_.front().video_header.codecHeader.VP9.temporal_idx;
   } else {
     return kNoTemporalIdx;
   }
 }
 
 bool VCMSessionInfo::LayerSync() const {
   if (packets_.empty())
     return false;
-  if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp8) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP8.layerSync;
-  } else if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp9) {
-    return packets_.front()
-        .codecSpecificHeader.codecHeader.VP9.temporal_up_switch;
+  if (packets_.front().video_header.codec == kRtpVideoVp8) {
+    return packets_.front().video_header.codecHeader.VP8.layerSync;
+  } else if (packets_.front().video_header.codec == kRtpVideoVp9) {
+    return packets_.front().video_header.codecHeader.VP9.temporal_up_switch;
   } else {
     return false;
   }
 }
 
 int VCMSessionInfo::Tl0PicId() const {
   if (packets_.empty())
     return kNoTl0PicIdx;
-  if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp8) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP8.tl0PicIdx;
-  } else if (packets_.front().codecSpecificHeader.codec == kRtpVideoVp9) {
-    return packets_.front().codecSpecificHeader.codecHeader.VP9.tl0_pic_idx;
+  if (packets_.front().video_header.codec == kRtpVideoVp8) {
+    return packets_.front().video_header.codecHeader.VP8.tl0PicIdx;
+  } else if (packets_.front().video_header.codec == kRtpVideoVp9) {
+    return packets_.front().video_header.codecHeader.VP9.tl0_pic_idx;
   } else {
     return kNoTl0PicIdx;
   }
 }
 
 bool VCMSessionInfo::NonReference() const {
-  if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRtpVideoVp8)
+  if (packets_.empty() || packets_.front().video_header.codec != kRtpVideoVp8)
     return false;
-  return packets_.front().codecSpecificHeader.codecHeader.VP8.nonReference;
+  return packets_.front().video_header.codecHeader.VP8.nonReference;
 }
 
 void VCMSessionInfo::SetGofInfo(const GofInfoVP9& gof_info, size_t idx) {
-  if (packets_.empty() ||
-      packets_.front().codecSpecificHeader.codec != kRtpVideoVp9 ||
-      packets_.front().codecSpecificHeader.codecHeader.VP9.flexible_mode) {
+  if (packets_.empty() || packets_.front().video_header.codec != kRtpVideoVp9 ||
+      packets_.front().video_header.codecHeader.VP9.flexible_mode) {
     return;
   }
-  packets_.front().codecSpecificHeader.codecHeader.VP9.temporal_idx =
+  packets_.front().video_header.codecHeader.VP9.temporal_idx =
       gof_info.temporal_idx[idx];
-  packets_.front().codecSpecificHeader.codecHeader.VP9.temporal_up_switch =
+  packets_.front().video_header.codecHeader.VP9.temporal_up_switch =
       gof_info.temporal_up_switch[idx];
-  packets_.front().codecSpecificHeader.codecHeader.VP9.num_ref_pics =
+  packets_.front().video_header.codecHeader.VP9.num_ref_pics =
       gof_info.num_ref_pics[idx];
   for (uint8_t i = 0; i < gof_info.num_ref_pics[idx]; ++i) {
-    packets_.front().codecSpecificHeader.codecHeader.VP9.pid_diff[i] =
+    packets_.front().video_header.codecHeader.VP9.pid_diff[i] =
         gof_info.pid_diff[idx][i];
   }
 }
 
 void VCMSessionInfo::Reset() {
   session_nack_ = false;
   complete_ = false;
   decodable_ = false;
   frame_type_ = kVideoFrameDelta;
   packets_.clear();
@@ skipping 28 matching lines @@
   // frame buffer.
   const uint8_t* packet_buffer = packet.dataPtr;
   packet.dataPtr = frame_buffer + offset;
 
   // We handle H.264 STAP-A packets in a special way as we need to remove the
   // two length bytes between each NAL unit, and potentially add start codes.
   // TODO(pbos): Remove H264 parsing from this step and use a fragmentation
   // header supplied by the H264 depacketizer.
   const size_t kH264NALHeaderLengthInBytes = 1;
   const size_t kLengthFieldLength = 2;
-  if (packet.codecSpecificHeader.codec == kRtpVideoH264 &&
-      packet.codecSpecificHeader.codecHeader.H264.packetization_type ==
-          kH264StapA) {
+  if (packet.video_header.codec == kRtpVideoH264 &&
+      packet.video_header.codecHeader.H264.packetization_type == kH264StapA) {
     size_t required_length = 0;
     const uint8_t* nalu_ptr = packet_buffer + kH264NALHeaderLengthInBytes;
     while (nalu_ptr < packet_buffer + packet.sizeBytes) {
       size_t length = BufferToUWord16(nalu_ptr);
       required_length +=
           length + (packet.insertStartCode ? kH264StartCodeLengthBytes : 0);
       nalu_ptr += kLengthFieldLength + length;
     }
     ShiftSubsequentPackets(packet_it, required_length);
     nalu_ptr = packet_buffer + kH264NALHeaderLengthInBytes;
@@ skipping 146 matching lines @@
   size_t new_length = 0;
   // Allocate space for max number of partitions
   fragmentation->VerifyAndAllocateFragmentationHeader(kMaxVP8Partitions);
   fragmentation->fragmentationVectorSize = 0;
   memset(fragmentation->fragmentationLength, 0,
          kMaxVP8Partitions * sizeof(size_t));
   if (packets_.empty())
     return new_length;
   PacketIterator it = FindNextPartitionBeginning(packets_.begin());
   while (it != packets_.end()) {
-    const int partition_id =
-        (*it).codecSpecificHeader.codecHeader.VP8.partitionId;
+    const int partition_id = (*it).video_header.codecHeader.VP8.partitionId;
     PacketIterator partition_end = FindPartitionEnd(it);
     fragmentation->fragmentationOffset[partition_id] =
         (*it).dataPtr - frame_buffer;
     assert(fragmentation->fragmentationOffset[partition_id] <
            frame_buffer_length);
     fragmentation->fragmentationLength[partition_id] =
         (*partition_end).dataPtr + (*partition_end).sizeBytes - (*it).dataPtr;
     assert(fragmentation->fragmentationLength[partition_id] <=
            frame_buffer_length);
     new_length += fragmentation->fragmentationLength[partition_id];
@@ skipping 15 matching lines @@
            fragmentation->fragmentationOffset[i] >=
                fragmentation->fragmentationOffset[i - 1]);
   }
   assert(new_length <= frame_buffer_length);
   return new_length;
 }
 
 VCMSessionInfo::PacketIterator VCMSessionInfo::FindNextPartitionBeginning(
     PacketIterator it) const {
   while (it != packets_.end()) {
-    if ((*it).codecSpecificHeader.codecHeader.VP8.beginningOfPartition) {
+    if ((*it).video_header.codecHeader.VP8.beginningOfPartition) {
       return it;
     }
     ++it;
   }
   return it;
 }
 
 VCMSessionInfo::PacketIterator VCMSessionInfo::FindPartitionEnd(
     PacketIterator it) const {
   assert((*it).codec == kVideoCodecVP8);
   PacketIterator prev_it = it;
-  const int partition_id =
-      (*it).codecSpecificHeader.codecHeader.VP8.partitionId;
+  const int partition_id = (*it).video_header.codecHeader.VP8.partitionId;
   while (it != packets_.end()) {
-    bool beginning =
-        (*it).codecSpecificHeader.codecHeader.VP8.beginningOfPartition;
-    int current_partition_id =
-        (*it).codecSpecificHeader.codecHeader.VP8.partitionId;
+    bool beginning = (*it).video_header.codecHeader.VP8.beginningOfPartition;
+    int current_partition_id = (*it).video_header.codecHeader.VP8.partitionId;
     bool packet_loss_found = (!beginning && !InSequence(it, prev_it));
     if (packet_loss_found ||
         (beginning && current_partition_id != partition_id)) {
       // Missing packet, the previous packet was the last in sequence.
       return prev_it;
     }
     prev_it = it;
     ++it;
   }
   return prev_it;
@@ skipping 147 matching lines @@
   if (empty_seq_num_high_ == -1)
     empty_seq_num_high_ = seq_num;
   else
     empty_seq_num_high_ = LatestSequenceNumber(seq_num, empty_seq_num_high_);
   if (empty_seq_num_low_ == -1 ||
       IsNewerSequenceNumber(empty_seq_num_low_, seq_num))
     empty_seq_num_low_ = seq_num;
 }
 
 }  // namespace webrtc