1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
/*
* Copyright (c) 2016 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.
*/
#ifndef API_NETEQ_TICK_TIMER_H_
#define API_NETEQ_TICK_TIMER_H_
#include <stdint.h>
#include <memory>
#include "rtc_base/checks.h"
namespace webrtc {
// Implements a time counter. The counter is advanced with the Increment()
// methods, and is queried with the ticks() accessor. It is assumed that one
// "tick" of the counter corresponds to 10 ms.
// A TickTimer object can provide two types of associated time-measuring
// objects: Stopwatch and Countdown.
class TickTimer {
public:
// Stopwatch measures time elapsed since it was started, by querying the
// associated TickTimer for the current time. The intended use is to request a
// new Stopwatch object from a TickTimer object with the GetNewStopwatch()
// method. Note: since the Stopwatch object contains a reference to the
// TickTimer it is associated with, it cannot outlive the TickTimer.
class Stopwatch {
public:
explicit Stopwatch(const TickTimer& ticktimer);
uint64_t ElapsedTicks() const { return ticktimer_.ticks() - starttick_; }
uint64_t ElapsedMs() const {
const uint64_t elapsed_ticks = ticktimer_.ticks() - starttick_;
const int ms_per_tick = ticktimer_.ms_per_tick();
return elapsed_ticks < UINT64_MAX / ms_per_tick
? elapsed_ticks * ms_per_tick
: UINT64_MAX;
}
private:
const TickTimer& ticktimer_;
const uint64_t starttick_;
};
// Countdown counts down from a given start value with each tick of the
// associated TickTimer, until zero is reached. The Finished() method will
// return true if zero has been reached, false otherwise. The intended use is
// to request a new Countdown object from a TickTimer object with the
// GetNewCountdown() method. Note: since the Countdown object contains a
// reference to the TickTimer it is associated with, it cannot outlive the
// TickTimer.
class Countdown {
public:
Countdown(const TickTimer& ticktimer, uint64_t ticks_to_count);
~Countdown();
bool Finished() const {
return stopwatch_->ElapsedTicks() >= ticks_to_count_;
}
private:
const std::unique_ptr<Stopwatch> stopwatch_;
const uint64_t ticks_to_count_;
};
TickTimer() : TickTimer(10) {}
explicit TickTimer(int ms_per_tick) : ms_per_tick_(ms_per_tick) {
RTC_DCHECK_GT(ms_per_tick_, 0);
}
TickTimer(const TickTimer&) = delete;
TickTimer& operator=(const TickTimer&) = delete;
void Increment() { ++ticks_; }
// Mainly intended for testing.
void Increment(uint64_t x) { ticks_ += x; }
uint64_t ticks() const { return ticks_; }
int ms_per_tick() const { return ms_per_tick_; }
// Returns a new Stopwatch object, based on the current TickTimer. Note that
// the new Stopwatch object contains a reference to the current TickTimer,
// and must therefore not outlive the TickTimer.
std::unique_ptr<Stopwatch> GetNewStopwatch() const {
return std::unique_ptr<Stopwatch>(new Stopwatch(*this));
}
// Returns a new Countdown object, based on the current TickTimer. Note that
// the new Countdown object contains a reference to the current TickTimer,
// and must therefore not outlive the TickTimer.
std::unique_ptr<Countdown> GetNewCountdown(uint64_t ticks_to_count) const {
return std::unique_ptr<Countdown>(new Countdown(*this, ticks_to_count));
}
private:
uint64_t ticks_ = 0;
const int ms_per_tick_;
};
} // namespace webrtc
#endif // API_NETEQ_TICK_TIMER_H_
|
