Repo created

TMessagesProj/jni/voip/webrtc/call/receive_time_calculator.cc

@@ -0,0 +1,120 @@
+/*
+ *  Copyright (c) 2018 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 "call/receive_time_calculator.h"
+
+#include <memory>
+#include <string>
+#include <type_traits>
+
+#include "rtc_base/experiments/field_trial_parser.h"
+#include "rtc_base/numerics/safe_minmax.h"
+
+namespace webrtc {
+namespace {
+
+const char kBweReceiveTimeCorrection[] = "WebRTC-Bwe-ReceiveTimeFix";
+}  // namespace
+
+ReceiveTimeCalculatorConfig::ReceiveTimeCalculatorConfig(
+    const FieldTrialsView& field_trials)
+    : max_packet_time_repair("maxrep", TimeDelta::Millis(2000)),
+      stall_threshold("stall", TimeDelta::Millis(5)),
+      tolerance("tol", TimeDelta::Millis(1)),
+      max_stall("maxstall", TimeDelta::Seconds(5)) {
+  std::string trial_string = field_trials.Lookup(kBweReceiveTimeCorrection);
+  ParseFieldTrial(
+      {&max_packet_time_repair, &stall_threshold, &tolerance, &max_stall},
+      trial_string);
+}
+ReceiveTimeCalculatorConfig::ReceiveTimeCalculatorConfig(
+    const ReceiveTimeCalculatorConfig&) = default;
+ReceiveTimeCalculatorConfig::~ReceiveTimeCalculatorConfig() = default;
+
+ReceiveTimeCalculator::ReceiveTimeCalculator(
+    const FieldTrialsView& field_trials)
+    : config_(field_trials) {}
+
+std::unique_ptr<ReceiveTimeCalculator>
+ReceiveTimeCalculator::CreateFromFieldTrial(
+    const FieldTrialsView& field_trials) {
+  if (!field_trials.IsEnabled(kBweReceiveTimeCorrection))
+    return nullptr;
+  return std::make_unique<ReceiveTimeCalculator>(field_trials);
+}
+
+int64_t ReceiveTimeCalculator::ReconcileReceiveTimes(int64_t packet_time_us,
+                                                     int64_t system_time_us,
+                                                     int64_t safe_time_us) {
+  int64_t stall_time_us = system_time_us - packet_time_us;
+  if (total_system_time_passed_us_ < config_.stall_threshold->us()) {
+    stall_time_us = rtc::SafeMin(stall_time_us, config_.max_stall->us());
+  }
+  int64_t corrected_time_us = safe_time_us - stall_time_us;
+
+  if (last_packet_time_us_ == -1 && stall_time_us < 0) {
+    static_clock_offset_us_ = stall_time_us;
+    corrected_time_us += static_clock_offset_us_;
+  } else if (last_packet_time_us_ > 0) {
+    // All repairs depend on variables being intialized
+    int64_t packet_time_delta_us = packet_time_us - last_packet_time_us_;
+    int64_t system_time_delta_us = system_time_us - last_system_time_us_;
+    int64_t safe_time_delta_us = safe_time_us - last_safe_time_us_;
+
+    // Repair backwards clock resets during initial stall. In this case, the
+    // reset is observed only in packet time but never in system time.
+    if (system_time_delta_us < 0)
+      total_system_time_passed_us_ += config_.stall_threshold->us();
+    else
+      total_system_time_passed_us_ += system_time_delta_us;
+    if (packet_time_delta_us < 0 &&
+        total_system_time_passed_us_ < config_.stall_threshold->us()) {
+      static_clock_offset_us_ -= packet_time_delta_us;
+    }
+    corrected_time_us += static_clock_offset_us_;
+
+    // Detect resets inbetween clock readings in socket and app.
+    bool forward_clock_reset =
+        corrected_time_us + config_.tolerance->us() < last_corrected_time_us_;
+    bool obvious_backward_clock_reset = system_time_us < packet_time_us;
+
+    // Harder case with backward clock reset during stall, the reset being
+    // smaller than the stall. Compensate throughout the stall.
+    bool small_backward_clock_reset =
+        !obvious_backward_clock_reset &&
+        safe_time_delta_us > system_time_delta_us + config_.tolerance->us();
+    bool stall_start =
+        packet_time_delta_us >= 0 &&
+        system_time_delta_us > packet_time_delta_us + config_.tolerance->us();
+    bool stall_is_over = safe_time_delta_us > config_.stall_threshold->us();
+    bool packet_time_caught_up =
+        packet_time_delta_us < 0 && system_time_delta_us >= 0;
+    if (stall_start && small_backward_clock_reset)
+      small_reset_during_stall_ = true;
+    else if (stall_is_over || packet_time_caught_up)
+      small_reset_during_stall_ = false;
+
+    // If resets are detected, advance time by (capped) packet time increase.
+    if (forward_clock_reset || obvious_backward_clock_reset ||
+        small_reset_during_stall_) {
+      corrected_time_us = last_corrected_time_us_ +
+                          rtc::SafeClamp(packet_time_delta_us, 0,
+                                         config_.max_packet_time_repair->us());
+    }
+  }
+
+  last_corrected_time_us_ = corrected_time_us;
+  last_packet_time_us_ = packet_time_us;
+  last_system_time_us_ = system_time_us;
+  last_safe_time_us_ = safe_time_us;
+  return corrected_time_us;
+}
+
+}  // namespace webrtc