Add sender controlled playout delay limits

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 180 matching lines @@
 
 size_t RTPSenderVideo::FECPacketOverhead() const {
   rtc::CritScope cs(&crit_);
   if (fec_enabled_) {
     // Overhead is FEC headers plus RED for FEC header plus anything in RTP
     // header beyond the 12 bytes base header (CSRC list, extensions...)
     // This reason for the header extensions to be included here is that
     // from an FEC viewpoint, they are part of the payload to be protected.
     // (The base RTP header is already protected by the FEC header.)
     return ForwardErrorCorrection::PacketOverhead() + REDForFECHeaderLength +
-           (_rtpSender.RTPHeaderLength() - kRtpHeaderSize);
+           (_rtpSender.RtpHeaderMaxLength() - kRtpHeaderSize);
   }
   return 0;
 }
 
 void RTPSenderVideo::SetFecParameters(const FecProtectionParams* delta_params,
                                       const FecProtectionParams* key_params) {
   rtc::CritScope cs(&crit_);
   RTC_DCHECK(delta_params);
   RTC_DCHECK(key_params);
   delta_fec_params_ = *delta_params;
   key_fec_params_ = *key_params;
 }
 
 int32_t RTPSenderVideo::SendVideo(const RtpVideoCodecTypes videoType,
                                   const FrameType frameType,
                                   const int8_t payloadType,
                                   const uint32_t captureTimeStamp,
                                   int64_t capture_time_ms,
                                   const uint8_t* payloadData,
                                   const size_t payloadSize,
                                   const RTPFragmentationHeader* fragmentation,
                                   const RTPVideoHeader* video_header) {
   if (payloadSize == 0) {
     return -1;
   }
 
   std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
       videoType, _rtpSender.MaxDataPayloadLength(),

[danilchap, 2016/06/02 12:12:34]

Please note that packetizer use this value to decide how much bytes it can put
per packet. Current design doesn't allow to change this value mid-frame.
So there is not much point to put a lot of effort into reducing space used by
rtp header extensions during this function.

[Irfan, 2016/06/02 18:15:53]

Right, with my updated change the length is treated as fixed.

       video_header ? &(video_header->codecHeader) : nullptr, frameType));
 
   StorageType storage;
   bool fec_enabled;
   bool first_frame = first_frame_sent_();
   {
     rtc::CritScope cs(&crit_);
     FecProtectionParams* fec_params =
         frameType == kVideoFrameKey ? &key_fec_params_ : &delta_fec_params_;
     producer_fec_.SetFecParameters(fec_params, 0);
     storage = packetizer->GetStorageType(_retransmissionSettings);
     fec_enabled = fec_enabled_;
   }
 
   // Register CVO rtp header extension at the first time when we receive a frame
   // with pending rotation.
   RTPSenderInterface::CVOMode cvo_mode = RTPSenderInterface::kCVONone;
   if (video_header && video_header->rotation != kVideoRotation_0) {
     cvo_mode = _rtpSender.ActivateCVORtpHeaderExtension();
   }
 
-  uint16_t rtp_header_length = _rtpSender.RTPHeaderLength();
+  int rtp_header_length = _rtpSender.RtpHeaderCurrentLength();
   size_t payload_bytes_to_send = payloadSize;
   const uint8_t* data = payloadData;
 
   // TODO(changbin): we currently don't support to configure the codec to
   // output multiple partitions for VP8. Should remove below check after the
   // issue is fixed.
   const RTPFragmentationHeader* frag =
       (videoType == kRtpVideoVp8) ? NULL : fragmentation;
 
   packetizer->SetPayloadData(data, payload_bytes_to_send, frag);
 
   bool first = true;
   bool last = false;
   while (!last) {
     uint8_t dataBuffer[IP_PACKET_SIZE] = {0};
     size_t payload_bytes_in_packet = 0;
-    if (!packetizer->NextPacket(&dataBuffer[rtp_header_length],
-                                &payload_bytes_in_packet, &last)) {
+
+    // Note that RTP header size is dynamically computed since there may be
+    // an optional RTP header extension.
+    if (!packetizer->NextPacket(
+            &dataBuffer[_rtpSender.RtpHeaderCurrentLength()],
+            &payload_bytes_in_packet, &last)) {
       return -1;
     }
 
     // Write RTP header.
-    // Set marker bit true if this is the last packet in frame.
     _rtpSender.BuildRTPheader(

[danilchap, 2016/06/02 12:12:34]

playout_delay_oracle_ is not protected by crit_
That means that extension might be changed after payload is filled, but before
this call to BuildRTPheader. BuildRTPheader then will use less bytes which would
calculate payload offset incorrectly.

May be would be clearer to protect playout_delay_oracle with crit_,
or set extension Active/Inactive, so that less mechanics could be used for
optional extensions.

Either way ensure rtp_header_length is unchanged during this function.


Do not try to be too nice about this code: I plan to change this code with
RtpPacket shortly (and probably replace inactive extension concept with
something less confusing).

[Irfan, 2016/06/02 18:15:53]

Thanks for pointing this out. With the updated change the playout delay
extension can get active or inactive only before each call to this method, so
this way we do not have the issue of it changing while preparing the header.

         dataBuffer, payloadType, last, captureTimeStamp, capture_time_ms);
+
     // According to
     // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/
     // ts_126114v120700p.pdf Section 7.4.5:
     // The MTSI client shall add the payload bytes as defined in this clause
     // onto the last RTP packet in each group of packets which make up a key
     // frame (I-frame or IDR frame in H.264 (AVC), or an IRAP picture in H.265
     // (HEVC)). The MTSI client may also add the payload bytes onto the last RTP
     // packet in each group of packets which make up another type of frame
     // (e.g. a P-Frame) only if the current value is different from the previous
     // value sent.
@@ skipping 60 matching lines @@
   rtc::CritScope cs(&crit_);
   return _retransmissionSettings;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   rtc::CritScope cs(&crit_);
   _retransmissionSettings = settings;
 }
 
 }  // namespace webrtc