Add sender controlled playout delay limits

webrtc/modules/rtp_rtcp/source/rtp_sender.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/rtp_rtcp/source/rtp_sender.h"
 
 #include <stdlib.h>  // srand
 #include <algorithm>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/call.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/playout_delay_oracle.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "webrtc/modules/rtp_rtcp/source/time_util.h"
 
 namespace webrtc {
 
 // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
 static const size_t kMaxPaddingLength = 224;
 static const int kSendSideDelayWindowMs = 1000;
 static const uint32_t kAbsSendTimeFraction = 18;
@@ skipping 449 matching lines @@
 
 int32_t RTPSender::SendOutgoingData(FrameType frame_type,
                                     int8_t payload_type,
                                     uint32_t capture_timestamp,
                                     int64_t capture_time_ms,
                                     const uint8_t* payload_data,
                                     size_t payload_size,
                                     const RTPFragmentationHeader* fragmentation,
                                     const RTPVideoHeader* rtp_hdr) {
   uint32_t ssrc;
+  uint16_t sequence_number;
   {
     // Drop this packet if we're not sending media packets.
     rtc::CritScope lock(&send_critsect_);
     ssrc = ssrc_;
+    sequence_number = sequence_number_;
     if (!sending_media_) {
       return 0;
     }
   }
   RtpVideoCodecTypes video_type = kRtpVideoGeneric;
   if (CheckPayloadType(payload_type, &video_type) != 0) {
     LOG(LS_ERROR) << "Don't send data with unknown payload type: "
                   << static_cast<int>(payload_type) << ".";
     return -1;
   }
 
   int32_t ret_val;
   if (audio_configured_) {
     TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", capture_timestamp,
                             "Send", "type", FrameTypeToString(frame_type));
     assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN ||
            frame_type == kEmptyFrame);
 
     ret_val = audio_->SendAudio(frame_type, payload_type, capture_timestamp,
                                 payload_data, payload_size, fragmentation);
   } else {
     TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms,
                             "Send", "type", FrameTypeToString(frame_type));
     assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN);
 
     if (frame_type == kEmptyFrame)
       return 0;
 
-    ret_val =
-        video_->SendVideo(video_type, frame_type, payload_type,
-                          capture_timestamp, capture_time_ms, payload_data,
-                          payload_size, fragmentation, rtp_hdr);
+    if (rtp_hdr)
+      playout_delay_oracle_.UpdateRequest(ssrc, rtp_hdr->playout_delay,
+                                          sequence_number);
+
+    ret_val = video_->SendVideo(
+        video_type, frame_type, payload_type, capture_timestamp,
+        capture_time_ms, payload_data, payload_size, fragmentation, rtp_hdr);
   }
 
   rtc::CritScope cs(&statistics_crit_);
   // Note: This is currently only counting for video.
   if (frame_type == kVideoFrameKey) {
     ++frame_counts_.key_frames;
   } else if (frame_type == kVideoFrameDelta) {
     ++frame_counts_.delta_frames;
   }
   if (frame_count_observer_) {
@@ skipping 274 matching lines @@
       if (bytes_re_sent > target_bytes) {
         break;  // Ignore the rest of the packets in the list.
       }
     }
   }
   if (bytes_re_sent > 0) {
     UpdateNACKBitRate(bytes_re_sent, now);
   }
 }
 
+void RTPSender::OnReceivedRtcpReceiverReport(
+    const ReportBlockList& report_blocks) {
+  rtc::CritScope lock(&send_critsect_);
+  playout_delay_oracle_.OnReceivedRtcpReceiverReport(report_blocks);
+}
+
 bool RTPSender::ProcessNACKBitRate(uint32_t now) {
   uint32_t num = 0;
   size_t byte_count = 0;
   const uint32_t kAvgIntervalMs = 1000;
   uint32_t target_bitrate = GetTargetBitrate();
 
   rtc::CritScope lock(&send_critsect_);
 
   if (target_bitrate == 0) {
     return true;
@@ skipping 193 matching lines @@
   // |capture_time_ms| <= 0 is considered invalid.
   // TODO(holmer): This should be changed all over Video Engine so that negative
   // time is consider invalid, while 0 is considered a valid time.
   if (capture_time_ms > 0) {
     UpdateTransmissionTimeOffset(buffer, length, rtp_header,
                                  now_ms - capture_time_ms);
   }
 
   UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms);
 
+  if (playout_delay_oracle_.send_playout_delay())
+    UpdatePlayoutDelayLimits(buffer, length, rtp_header,
+                             playout_delay_oracle_.min_playout_delay_ms(),
+                             playout_delay_oracle_.max_playout_delay_ms());
+
   // Used for NACK and to spread out the transmission of packets.
   if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) !=
       0) {
     return -1;
   }
 
   if (paced_sender_) {
     // Correct offset between implementations of millisecond time stamps in
     // TickTime and Clock.
     int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
@@ skipping 216 matching lines @@
       case kRtpExtensionAbsoluteSendTime:
         block_length = BuildAbsoluteSendTimeExtension(extension_data);
         break;
       case kRtpExtensionVideoRotation:
         block_length = BuildVideoRotationExtension(extension_data);
         break;
       case kRtpExtensionTransportSequenceNumber:
         block_length = BuildTransportSequenceNumberExtension(
             extension_data, transport_sequence_number_);
         break;
+      case kRtpExtensionPlayoutDelay:
+        if (playout_delay_oracle_.send_playout_delay()) {
+          block_length = BuildPlayoutDelayExtension(
+              extension_data, playout_delay_oracle_.min_playout_delay_ms(),
+              playout_delay_oracle_.max_playout_delay_ms());
+        }
+        break;
       default:
         assert(false);
     }
     total_block_length += block_length;
     type = rtp_header_extension_map_.Next(type);
   }
   if (total_block_length == 0) {
     // No extension added.
     return 0;
   }
@@ skipping 155 matching lines @@
   }
   size_t pos = 0;
   const uint8_t len = 1;
   data_buffer[pos++] = (id << 4) + len;
   ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, sequence_number);
   pos += 2;
   assert(pos == kTransportSequenceNumberLength);
   return kTransportSequenceNumberLength;
 }
 
+uint8_t RTPSender::BuildPlayoutDelayExtension(
+    uint8_t* data_buffer,
+    uint16_t min_playout_delay_ms,
+    uint16_t max_playout_delay_ms) const {
+  RTC_DCHECK_LE(min_playout_delay_ms, kPlayoutDelayMaxMs);
+  RTC_DCHECK_LE(max_playout_delay_ms, kPlayoutDelayMaxMs);
+  //   0                   1                   2                   3
+  //   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+  //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  //  |  ID   | len=2 |   MIN delay           |   MAX delay           |
+  //  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+  uint8_t id;
+  if (rtp_header_extension_map_.GetId(kRtpExtensionPlayoutDelay, &id) != 0) {
+    // Not registered.
+    return 0;
+  }
+  size_t pos = 0;
+  const uint8_t len = 2;
+  // Convert MS to value to be sent on extension header.
+  uint16_t min_playout = min_playout_delay_ms / kPlayoutDelayGranularityMs;
+  uint16_t max_playout = max_playout_delay_ms / kPlayoutDelayGranularityMs;
+
+  data_buffer[pos++] = (id << 4) + len;
+  data_buffer[pos++] = min_playout >> 4;
+  data_buffer[pos++] = ((min_playout & 0xf) << 4) | (max_playout >> 8);
+  data_buffer[pos++] = max_playout & 0xff;
+  assert(pos == kPlayoutDelayLength);
+  return kPlayoutDelayLength;
+}
+
 bool RTPSender::FindHeaderExtensionPosition(RTPExtensionType type,
                                             const uint8_t* rtp_packet,
                                             size_t rtp_packet_length,
                                             const RTPHeader& rtp_header,
                                             size_t* position) const {
   // Get length until start of header extension block.
   int extension_block_pos =
       rtp_header_extension_map_.GetLengthUntilBlockStartInBytes(type);
   if (extension_block_pos < 0) {
     LOG(LS_WARNING) << "Failed to find extension position for " << type
@@ skipping 173 matching lines @@
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
   BuildTransportSequenceNumberExtension(rtp_packet + offset, sequence_number);
   return true;
 }
 
+void RTPSender::UpdatePlayoutDelayLimits(uint8_t* rtp_packet,
+                                         size_t rtp_packet_length,
+                                         const RTPHeader& rtp_header,
+                                         uint16_t min_playout_delay_ms,
+                                         uint16_t max_playout_delay_ms) const {
+  size_t offset;
+  rtc::CritScope lock(&send_critsect_);
+
+  switch (VerifyExtension(kRtpExtensionPlayoutDelay, rtp_packet,
+                          rtp_packet_length, rtp_header, kPlayoutDelayLength,
+                          &offset)) {
+    case ExtensionStatus::kNotRegistered:
+      return;
+    case ExtensionStatus::kError:
+      LOG(LS_WARNING) << "Failed to update playout delay limits";
+      return;
+    case ExtensionStatus::kOk:
+      break;
+    default:
+      RTC_NOTREACHED();
+  }
+
+  int length = BuildPlayoutDelayExtension(
+      rtp_packet + offset, min_playout_delay_ms, max_playout_delay_ms);
+  assert(length == kPlayoutDelayLength);
+  return;
+}
+
 bool RTPSender::AllocateTransportSequenceNumber(int* packet_id) const {
   if (!transport_sequence_number_allocator_)
     return false;
 
   *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
   return true;
 }
 
 void RTPSender::SetSendingStatus(bool enabled) {
   if (enabled) {
@@ skipping 260 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc