Line data    Source code

       1             : /*
       2             :  *  Copyright 2005 The WebRTC Project Authors. All rights reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #ifndef WEBRTC_BASE_TIMEUTILS_H_
      12             : #define WEBRTC_BASE_TIMEUTILS_H_
      13             : 
      14             : #include <stdint.h>
      15             : #include <time.h>
      16             : 
      17             : #include <ctime>
      18             : 
      19             : namespace rtc {
      20             : 
      21             : static const int64_t kNumMillisecsPerSec = INT64_C(1000);
      22             : static const int64_t kNumMicrosecsPerSec = INT64_C(1000000);
      23             : static const int64_t kNumNanosecsPerSec = INT64_C(1000000000);
      24             : 
      25             : static const int64_t kNumMicrosecsPerMillisec =
      26             :     kNumMicrosecsPerSec / kNumMillisecsPerSec;
      27             : static const int64_t kNumNanosecsPerMillisec =
      28             :     kNumNanosecsPerSec / kNumMillisecsPerSec;
      29             : static const int64_t kNumNanosecsPerMicrosec =
      30             :     kNumNanosecsPerSec / kNumMicrosecsPerSec;
      31             : 
      32             : // TODO(honghaiz): Define a type for the time value specifically.
      33             : 
      34             : class ClockInterface {
      35             :  public:
      36             :   virtual ~ClockInterface() {}
      37             :   virtual int64_t TimeNanos() const = 0;
      38             : };
      39             : 
      40             : // Sets the global source of time. This is useful mainly for unit tests.
      41             : //
      42             : // Returns the previously set ClockInterface, or nullptr if none is set.
      43             : //
      44             : // Does not transfer ownership of the clock. SetClockForTesting(nullptr)
      45             : // should be called before the ClockInterface is deleted.
      46             : //
      47             : // This method is not thread-safe; it should only be used when no other thread
      48             : // is running (for example, at the start/end of a unit test, or start/end of
      49             : // main()).
      50             : //
      51             : // TODO(deadbeef): Instead of having functions that access this global
      52             : // ClockInterface, we may want to pass the ClockInterface into everything
      53             : // that uses it, eliminating the need for a global variable and this function.
      54             : ClockInterface* SetClockForTesting(ClockInterface* clock);
      55             : 
      56             : // Returns the actual system time, even if a clock is set for testing.
      57             : // Useful for timeouts while using a test clock, or for logging.
      58             : int64_t SystemTimeNanos();
      59             : int64_t SystemTimeMillis();
      60             : 
      61             : // Returns the current time in milliseconds in 32 bits.
      62             : uint32_t Time32();
      63             : 
      64             : // Returns the current time in milliseconds in 64 bits.
      65             : int64_t TimeMillis();
      66             : // Deprecated. Do not use this in any new code.
      67             : inline int64_t Time() {
      68             :   return TimeMillis();
      69             : }
      70             : 
      71             : // Returns the current time in microseconds.
      72             : int64_t TimeMicros();
      73             : 
      74             : // Returns the current time in nanoseconds.
      75             : int64_t TimeNanos();
      76             : 
      77             : 
      78             : // Returns a future timestamp, 'elapsed' milliseconds from now.
      79             : int64_t TimeAfter(int64_t elapsed);
      80             : 
      81             : // Number of milliseconds that would elapse between 'earlier' and 'later'
      82             : // timestamps.  The value is negative if 'later' occurs before 'earlier'.
      83             : int64_t TimeDiff(int64_t later, int64_t earlier);
      84             : int32_t TimeDiff32(uint32_t later, uint32_t earlier);
      85             : 
      86             : // The number of milliseconds that have elapsed since 'earlier'.
      87           0 : inline int64_t TimeSince(int64_t earlier) {
      88           0 :   return TimeMillis() - earlier;
      89             : }
      90             : 
      91             : // The number of milliseconds that will elapse between now and 'later'.
      92             : inline int64_t TimeUntil(int64_t later) {
      93             :   return later - TimeMillis();
      94             : }
      95             : 
      96             : class TimestampWrapAroundHandler {
      97             :  public:
      98             :   TimestampWrapAroundHandler();
      99             : 
     100             :   int64_t Unwrap(uint32_t ts);
     101             : 
     102             :  private:
     103             :   uint32_t last_ts_;
     104             :   int64_t num_wrap_;
     105             : };
     106             : 
     107             : // Convert from std::tm, which is relative to 1900-01-01 00:00 to number of
     108             : // seconds from 1970-01-01 00:00 ("epoch").  Don't return time_t since that
     109             : // is still 32 bits on many systems.
     110             : int64_t TmToSeconds(const std::tm& tm);
     111             : 
     112             : // Return the number of microseconds since January 1, 1970, UTC.
     113             : // Useful mainly when producing logs to be correlated with other
     114             : // devices, and when the devices in question all have properly
     115             : // synchronized clocks.
     116             : //
     117             : // Note that this function obeys the system's idea about what the time
     118             : // is. It is not guaranteed to be monotonic; it will jump in case the
     119             : // system time is changed, e.g., by some other process calling
     120             : // settimeofday. Always use rtc::TimeMicros(), not this function, for
     121             : // measuring time intervals and timeouts.
     122             : int64_t TimeUTCMicros();
     123             : 
     124             : }  // namespace rtc
     125             : 
     126             : #endif  // WEBRTC_BASE_TIMEUTILS_H_