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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* Copyright 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <cmath>
#include <limits>
#include <ostream>
#include <string>
#include <type_traits>
#include <android-base/stringprintf.h>
#include <utils/Timers.h>
namespace android {
// Frames per second, stored as floating-point frequency. Provides conversion from/to period in
// nanoseconds, and relational operators with precision threshold.
//
// const Fps fps = 60_Hz;
//
// using namespace fps_approx_ops;
// assert(fps == Fps::fromPeriodNsecs(16'666'667));
//
class Fps {
public:
constexpr Fps() = default;
static constexpr Fps fromValue(float frequency) {
return frequency > 0.f ? Fps(frequency, static_cast<nsecs_t>(1e9f / frequency)) : Fps();
}
static constexpr Fps fromPeriodNsecs(nsecs_t period) {
return period > 0 ? Fps(1e9f / period, period) : Fps();
}
constexpr bool isValid() const { return mFrequency > 0.f; }
constexpr float getValue() const { return mFrequency; }
int getIntValue() const { return static_cast<int>(std::round(mFrequency)); }
constexpr nsecs_t getPeriodNsecs() const { return mPeriod; }
private:
constexpr Fps(float frequency, nsecs_t period) : mFrequency(frequency), mPeriod(period) {}
float mFrequency = 0.f;
nsecs_t mPeriod = 0;
};
struct FpsRange {
Fps min = Fps::fromValue(0.f);
Fps max = Fps::fromValue(std::numeric_limits<float>::max());
bool includes(Fps) const;
};
static_assert(std::is_trivially_copyable_v<Fps>);
constexpr Fps operator""_Hz(unsigned long long frequency) {
return Fps::fromValue(static_cast<float>(frequency));
}
constexpr Fps operator""_Hz(long double frequency) {
return Fps::fromValue(static_cast<float>(frequency));
}
inline bool isStrictlyLess(Fps lhs, Fps rhs) {
return lhs.getValue() < rhs.getValue();
}
// Does not satisfy equivalence relation.
inline bool isApproxEqual(Fps lhs, Fps rhs) {
// TODO(b/185536303): Replace with ULP distance.
return std::abs(lhs.getValue() - rhs.getValue()) < 0.001f;
}
// Does not satisfy strict weak order.
inline bool isApproxLess(Fps lhs, Fps rhs) {
return isStrictlyLess(lhs, rhs) && !isApproxEqual(lhs, rhs);
}
namespace fps_approx_ops {
inline bool operator==(Fps lhs, Fps rhs) {
return isApproxEqual(lhs, rhs);
}
inline bool operator<(Fps lhs, Fps rhs) {
return isApproxLess(lhs, rhs);
}
inline bool operator!=(Fps lhs, Fps rhs) {
return !isApproxEqual(lhs, rhs);
}
inline bool operator>(Fps lhs, Fps rhs) {
return isApproxLess(rhs, lhs);
}
inline bool operator<=(Fps lhs, Fps rhs) {
return !isApproxLess(rhs, lhs);
}
inline bool operator>=(Fps lhs, Fps rhs) {
return !isApproxLess(lhs, rhs);
}
inline bool operator==(FpsRange lhs, FpsRange rhs) {
return isApproxEqual(lhs.min, rhs.min) && isApproxEqual(lhs.max, rhs.max);
}
inline bool operator!=(FpsRange lhs, FpsRange rhs) {
return !(lhs == rhs);
}
} // namespace fps_approx_ops
inline bool FpsRange::includes(Fps fps) const {
using fps_approx_ops::operator<=;
return min <= fps && fps <= max;
}
struct FpsApproxEqual {
bool operator()(Fps lhs, Fps rhs) const { return isApproxEqual(lhs, rhs); }
};
inline std::string to_string(Fps fps) {
return base::StringPrintf("%.2f Hz", fps.getValue());
}
inline std::ostream& operator<<(std::ostream& stream, Fps fps) {
return stream << to_string(fps);
}
inline std::string to_string(FpsRange range) {
const auto [min, max] = range;
return base::StringPrintf("[%s, %s]", to_string(min).c_str(), to_string(max).c_str());
}
} // namespace android
|
