1 /*
2  *  Copyright (c) 2013 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 #include "webrtc/system_wrappers/include/clock.h"
12 
13 #if defined(_WIN32)
14 // Windows needs to be included before mmsystem.h
15 #include "webrtc/base/win32.h"
16 #include <MMSystem.h>
17 #elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
18 #include <sys/time.h>
19 #include <time.h>
20 #endif
21 
22 #include "webrtc/base/criticalsection.h"
23 #include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
24 #include "webrtc/system_wrappers/include/tick_util.h"
25 
26 namespace webrtc {
27 
28 const double kNtpFracPerMs = 4.294967296E6;
29 
NtpToMs(uint32_t ntp_secs,uint32_t ntp_frac)30 int64_t Clock::NtpToMs(uint32_t ntp_secs, uint32_t ntp_frac) {
31   const double ntp_frac_ms = static_cast<double>(ntp_frac) / kNtpFracPerMs;
32   return 1000 * static_cast<int64_t>(ntp_secs) +
33       static_cast<int64_t>(ntp_frac_ms + 0.5);
34 }
35 
36 class RealTimeClock : public Clock {
37   // Return a timestamp in milliseconds relative to some arbitrary source; the
38   // source is fixed for this clock.
TimeInMilliseconds() const39   int64_t TimeInMilliseconds() const override {
40     return TickTime::MillisecondTimestamp();
41   }
42 
43   // Return a timestamp in microseconds relative to some arbitrary source; the
44   // source is fixed for this clock.
TimeInMicroseconds() const45   int64_t TimeInMicroseconds() const override {
46     return TickTime::MicrosecondTimestamp();
47   }
48 
49   // Retrieve an NTP absolute timestamp in seconds and fractions of a second.
CurrentNtp(uint32_t & seconds,uint32_t & fractions) const50   void CurrentNtp(uint32_t& seconds, uint32_t& fractions) const override {
51     timeval tv = CurrentTimeVal();
52     double microseconds_in_seconds;
53     Adjust(tv, &seconds, &microseconds_in_seconds);
54     fractions = static_cast<uint32_t>(
55         microseconds_in_seconds * kMagicNtpFractionalUnit + 0.5);
56   }
57 
58   // Retrieve an NTP absolute timestamp in milliseconds.
CurrentNtpInMilliseconds() const59   int64_t CurrentNtpInMilliseconds() const override {
60     timeval tv = CurrentTimeVal();
61     uint32_t seconds;
62     double microseconds_in_seconds;
63     Adjust(tv, &seconds, &microseconds_in_seconds);
64     return 1000 * static_cast<int64_t>(seconds) +
65         static_cast<int64_t>(1000.0 * microseconds_in_seconds + 0.5);
66   }
67 
68  protected:
69   virtual timeval CurrentTimeVal() const = 0;
70 
Adjust(const timeval & tv,uint32_t * adjusted_s,double * adjusted_us_in_s)71   static void Adjust(const timeval& tv, uint32_t* adjusted_s,
72                      double* adjusted_us_in_s) {
73     *adjusted_s = tv.tv_sec + kNtpJan1970;
74     *adjusted_us_in_s = tv.tv_usec / 1e6;
75 
76     if (*adjusted_us_in_s >= 1) {
77       *adjusted_us_in_s -= 1;
78       ++*adjusted_s;
79     } else if (*adjusted_us_in_s < -1) {
80       *adjusted_us_in_s += 1;
81       --*adjusted_s;
82     }
83   }
84 };
85 
86 #if defined(_WIN32)
87 // TODO(pbos): Consider modifying the implementation to synchronize itself
88 // against system time (update ref_point_, make it non-const) periodically to
89 // prevent clock drift.
90 class WindowsRealTimeClock : public RealTimeClock {
91  public:
WindowsRealTimeClock()92   WindowsRealTimeClock()
93       : last_time_ms_(0),
94         num_timer_wraps_(0),
95         ref_point_(GetSystemReferencePoint()) {}
96 
~WindowsRealTimeClock()97   virtual ~WindowsRealTimeClock() {}
98 
99  protected:
100   struct ReferencePoint {
101     FILETIME file_time;
102     LARGE_INTEGER counter_ms;
103   };
104 
CurrentTimeVal() const105   timeval CurrentTimeVal() const override {
106     const uint64_t FILETIME_1970 = 0x019db1ded53e8000;
107 
108     FILETIME StartTime;
109     uint64_t Time;
110     struct timeval tv;
111 
112     // We can't use query performance counter since they can change depending on
113     // speed stepping.
114     GetTime(&StartTime);
115 
116     Time = (((uint64_t) StartTime.dwHighDateTime) << 32) +
117            (uint64_t) StartTime.dwLowDateTime;
118 
119     // Convert the hecto-nano second time to tv format.
120     Time -= FILETIME_1970;
121 
122     tv.tv_sec = (uint32_t)(Time / (uint64_t)10000000);
123     tv.tv_usec = (uint32_t)((Time % (uint64_t)10000000) / 10);
124     return tv;
125   }
126 
GetTime(FILETIME * current_time) const127   void GetTime(FILETIME* current_time) const {
128     DWORD t;
129     LARGE_INTEGER elapsed_ms;
130     {
131       rtc::CritScope lock(&crit_);
132       // time MUST be fetched inside the critical section to avoid non-monotonic
133       // last_time_ms_ values that'll register as incorrect wraparounds due to
134       // concurrent calls to GetTime.
135       t = timeGetTime();
136       if (t < last_time_ms_)
137         num_timer_wraps_++;
138       last_time_ms_ = t;
139       elapsed_ms.HighPart = num_timer_wraps_;
140     }
141     elapsed_ms.LowPart = t;
142     elapsed_ms.QuadPart = elapsed_ms.QuadPart - ref_point_.counter_ms.QuadPart;
143 
144     // Translate to 100-nanoseconds intervals (FILETIME resolution)
145     // and add to reference FILETIME to get current FILETIME.
146     ULARGE_INTEGER filetime_ref_as_ul;
147     filetime_ref_as_ul.HighPart = ref_point_.file_time.dwHighDateTime;
148     filetime_ref_as_ul.LowPart = ref_point_.file_time.dwLowDateTime;
149     filetime_ref_as_ul.QuadPart +=
150         static_cast<ULONGLONG>((elapsed_ms.QuadPart) * 1000 * 10);
151 
152     // Copy to result
153     current_time->dwHighDateTime = filetime_ref_as_ul.HighPart;
154     current_time->dwLowDateTime = filetime_ref_as_ul.LowPart;
155   }
156 
GetSystemReferencePoint()157   static ReferencePoint GetSystemReferencePoint() {
158     ReferencePoint ref = {};
159     FILETIME ft0 = {};
160     FILETIME ft1 = {};
161     // Spin waiting for a change in system time. As soon as this change happens,
162     // get the matching call for timeGetTime() as soon as possible. This is
163     // assumed to be the most accurate offset that we can get between
164     // timeGetTime() and system time.
165 
166     // Set timer accuracy to 1 ms.
167     timeBeginPeriod(1);
168     GetSystemTimeAsFileTime(&ft0);
169     do {
170       GetSystemTimeAsFileTime(&ft1);
171 
172       ref.counter_ms.QuadPart = timeGetTime();
173       Sleep(0);
174     } while ((ft0.dwHighDateTime == ft1.dwHighDateTime) &&
175              (ft0.dwLowDateTime == ft1.dwLowDateTime));
176     ref.file_time = ft1;
177     timeEndPeriod(1);
178     return ref;
179   }
180 
181   // mutable as time-accessing functions are const.
182   mutable rtc::CriticalSection crit_;
183   mutable DWORD last_time_ms_;
184   mutable LONG num_timer_wraps_;
185   const ReferencePoint ref_point_;
186 };
187 
188 #elif ((defined WEBRTC_LINUX) || (defined WEBRTC_MAC))
189 class UnixRealTimeClock : public RealTimeClock {
190  public:
UnixRealTimeClock()191   UnixRealTimeClock() {}
192 
~UnixRealTimeClock()193   ~UnixRealTimeClock() override {}
194 
195  protected:
CurrentTimeVal() const196   timeval CurrentTimeVal() const override {
197     struct timeval tv;
198     struct timezone tz;
199     tz.tz_minuteswest = 0;
200     tz.tz_dsttime = 0;
201     gettimeofday(&tv, &tz);
202     return tv;
203   }
204 };
205 #endif
206 
207 #if defined(_WIN32)
208 static WindowsRealTimeClock* volatile g_shared_clock = nullptr;
209 #endif
GetRealTimeClock()210 Clock* Clock::GetRealTimeClock() {
211 #if defined(_WIN32)
212   // This read relies on volatile read being atomic-load-acquire. This is
213   // true in MSVC since at least 2005:
214   // "A read of a volatile object (volatile read) has Acquire semantics"
215   if (g_shared_clock != nullptr)
216     return g_shared_clock;
217   WindowsRealTimeClock* clock = new WindowsRealTimeClock;
218   if (InterlockedCompareExchangePointer(
219           reinterpret_cast<void* volatile*>(&g_shared_clock), clock, nullptr) !=
220       nullptr) {
221     // g_shared_clock was assigned while we constructed/tried to assign our
222     // instance, delete our instance and use the existing one.
223     delete clock;
224   }
225   return g_shared_clock;
226 #elif defined(WEBRTC_LINUX) || defined(WEBRTC_MAC)
227   static UnixRealTimeClock clock;
228   return &clock;
229 #else
230   return NULL;
231 #endif
232 }
233 
SimulatedClock(int64_t initial_time_us)234 SimulatedClock::SimulatedClock(int64_t initial_time_us)
235     : time_us_(initial_time_us), lock_(RWLockWrapper::CreateRWLock()) {
236 }
237 
~SimulatedClock()238 SimulatedClock::~SimulatedClock() {
239 }
240 
TimeInMilliseconds() const241 int64_t SimulatedClock::TimeInMilliseconds() const {
242   ReadLockScoped synchronize(*lock_);
243   return (time_us_ + 500) / 1000;
244 }
245 
TimeInMicroseconds() const246 int64_t SimulatedClock::TimeInMicroseconds() const {
247   ReadLockScoped synchronize(*lock_);
248   return time_us_;
249 }
250 
CurrentNtp(uint32_t & seconds,uint32_t & fractions) const251 void SimulatedClock::CurrentNtp(uint32_t& seconds, uint32_t& fractions) const {
252   int64_t now_ms = TimeInMilliseconds();
253   seconds = (now_ms / 1000) + kNtpJan1970;
254   fractions =
255       static_cast<uint32_t>((now_ms % 1000) * kMagicNtpFractionalUnit / 1000);
256 }
257 
CurrentNtpInMilliseconds() const258 int64_t SimulatedClock::CurrentNtpInMilliseconds() const {
259   return TimeInMilliseconds() + 1000 * static_cast<int64_t>(kNtpJan1970);
260 }
261 
AdvanceTimeMilliseconds(int64_t milliseconds)262 void SimulatedClock::AdvanceTimeMilliseconds(int64_t milliseconds) {
263   AdvanceTimeMicroseconds(1000 * milliseconds);
264 }
265 
AdvanceTimeMicroseconds(int64_t microseconds)266 void SimulatedClock::AdvanceTimeMicroseconds(int64_t microseconds) {
267   WriteLockScoped synchronize(*lock_);
268   time_us_ += microseconds;
269 }
270 
271 };  // namespace webrtc
272