Implement RTP keepalive in native stack.

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.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_rtcp_impl.h"
 
 #include <string.h>
 
+#include <algorithm>
 #include <set>
 #include <string>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_types.h"
 #include "webrtc/config.h"
 
 #ifdef _WIN32
 // Disable warning C4355: 'this' : used in base member initializer list.
 #pragma warning(disable : 4355)
 #endif
 
 namespace webrtc {
+namespace {
+const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
+const int64_t kRtpRtcpRttProcessTimeMs = 1000;
+const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
+}  // namespace
 
 RTPExtensionType StringToRtpExtensionType(const std::string& extension) {
   if (extension == RtpExtension::kTimestampOffsetUri)
     return kRtpExtensionTransmissionTimeOffset;
   if (extension == RtpExtension::kAudioLevelUri)
     return kRtpExtensionAudioLevel;
   if (extension == RtpExtension::kAbsSendTimeUri)
     return kRtpExtensionAbsoluteSendTime;
   if (extension == RtpExtension::kVideoRotationUri)
     return kRtpExtensionVideoRotation;
@@ skipping 43 matching lines @@
       rtcp_receiver_(configuration.clock,
                      configuration.receiver_only,
                      configuration.rtcp_packet_type_counter_observer,
                      configuration.bandwidth_callback,
                      configuration.intra_frame_callback,
                      configuration.transport_feedback_callback,
                      configuration.bitrate_allocation_observer,
                      this),
       clock_(configuration.clock),
       audio_(configuration.audio),
-      last_process_time_(configuration.clock->TimeInMilliseconds()),
-      last_bitrate_process_time_(configuration.clock->TimeInMilliseconds()),
-      last_rtt_process_time_(configuration.clock->TimeInMilliseconds()),
+      keepalive_config_(configuration.keepalive_config),
+      last_bitrate_process_time_(clock_->TimeInMilliseconds()),
+      last_rtt_process_time_(clock_->TimeInMilliseconds()),
+      next_process_time_(clock_->TimeInMilliseconds() +
+                         kRtpRtcpMaxIdleTimeProcessMs),
+      next_keepalive_time_(-1),
       packet_overhead_(28),  // IPV4 UDP.
       nack_last_time_sent_full_(0),
       nack_last_time_sent_full_prev_(0),
       nack_last_seq_number_sent_(0),
       key_frame_req_method_(kKeyFrameReqPliRtcp),
       remote_bitrate_(configuration.remote_bitrate_estimator),
       rtt_stats_(configuration.rtt_stats),
       rtt_ms_(0) {
   if (!configuration.receiver_only) {
     rtp_sender_.reset(new RTPSender(
         configuration.audio,
         configuration.clock,
         configuration.outgoing_transport,
         configuration.paced_sender,
         configuration.flexfec_sender,
         configuration.transport_sequence_number_allocator,
         configuration.transport_feedback_callback,
         configuration.send_bitrate_observer,
         configuration.send_frame_count_observer,
         configuration.send_side_delay_observer,
         configuration.event_log,
         configuration.send_packet_observer,
         configuration.retransmission_rate_limiter,
         configuration.overhead_observer));
     // Make sure rtcp sender use same timestamp offset as rtp sender.
     rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
+
+    if (keepalive_config_.timeout_interval_ms != -1) {
+      next_keepalive_time_ =
+          clock_->TimeInMilliseconds() + keepalive_config_.timeout_interval_ms;
+    }
   }
 
   // Set default packet size limit.
   // TODO(nisse): Kind-of duplicates
   // webrtc::VideoSendStream::Config::Rtp::kDefaultMaxPacketSize.
   const size_t kTcpOverIpv4HeaderSize = 40;
   SetMaxRtpPacketSize(IP_PACKET_SIZE - kTcpOverIpv4HeaderSize);
 }
 
 // Returns the number of milliseconds until the module want a worker thread
 // to call Process.
 int64_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
-  const int64_t now = clock_->TimeInMilliseconds();
-  const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
-  return kRtpRtcpMaxIdleTimeProcessMs - (now - last_process_time_);
+  return std::max<int64_t>(0,
+                           next_process_time_ - clock_->TimeInMilliseconds());
 }
 
 // Process any pending tasks such as timeouts (non time critical events).
 void ModuleRtpRtcpImpl::Process() {
   const int64_t now = clock_->TimeInMilliseconds();
-  last_process_time_ = now;
+  next_process_time_ = now + kRtpRtcpMaxIdleTimeProcessMs;
 
   if (rtp_sender_) {
-    const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
     if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
       rtp_sender_->ProcessBitrate();
       last_bitrate_process_time_ = now;
+      next_process_time_ =
+          std::min(next_process_time_, now + kRtpRtcpBitrateProcessTimeMs);
+    }
+    if (keepalive_config_.timeout_interval_ms > 0 &&
+        now >= next_keepalive_time_) {
+      int64_t last_send_time_ms = rtp_sender_->LastTimestampTimeMs();
+      // If no packet has been sent, |last_send_time_ms| will be 0, and so the
+      // keep-alive will be triggered as expected.
+      if (now >= last_send_time_ms + keepalive_config_.timeout_interval_ms) {
+        rtp_sender_->SendKeepAlive(keepalive_config_.payload_type);
+        next_keepalive_time_ = now + keepalive_config_.timeout_interval_ms;
+      } else {
+        next_keepalive_time_ =
+            last_send_time_ms + keepalive_config_.timeout_interval_ms;
+      }
+      next_process_time_ = std::min(next_process_time_, next_keepalive_time_);
     }
   }
-  const int64_t kRtpRtcpRttProcessTimeMs = 1000;
+
   bool process_rtt = now >= last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs;
   if (rtcp_sender_.Sending()) {
     // Process RTT if we have received a receiver report and we haven't
     // processed RTT for at least |kRtpRtcpRttProcessTimeMs| milliseconds.
     if (rtcp_receiver_.LastReceivedReceiverReport() >
         last_rtt_process_time_ && process_rtt) {
       std::vector<RTCPReportBlock> receive_blocks;
       rtcp_receiver_.StatisticsReceived(&receive_blocks);
       int64_t max_rtt = 0;
       for (std::vector<RTCPReportBlock>::iterator it = receive_blocks.begin();
@@ skipping 33 matching lines @@
        int64_t rtt_ms;
        if (rtt_stats_ && rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)) {
          rtt_stats_->OnRttUpdate(rtt_ms);
        }
     }
   }
 
   // Get processed rtt.
   if (process_rtt) {
     last_rtt_process_time_ = now;
+    next_process_time_ = std::min(
+        next_process_time_, last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs);
     if (rtt_stats_) {
       // Make sure we have a valid RTT before setting.
       int64_t last_rtt = rtt_stats_->LastProcessedRtt();
       if (last_rtt >= 0)
         set_rtt_ms(last_rtt);
     }
   }
 
   if (rtcp_sender_.TimeToSendRTCPReport())
     rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
@@ skipping 672 matching lines @@
 StreamDataCountersCallback*
     ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
   return rtp_sender_->GetRtpStatisticsCallback();
 }
 
 void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
     const BitrateAllocation& bitrate) {
   rtcp_sender_.SetVideoBitrateAllocation(bitrate);
 }
 }  // namespace webrtc