Rename factory names for Frequency unit type
to follow regular function name style
Bug: webrtc:9709
Change-Id: Idb2ad7af0b185c4b696afddb4a2eab1613901f69
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168528
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30525}
diff --git a/api/units/data_rate.h b/api/units/data_rate.h
index 949ecea..46c6d0f 100644
--- a/api/units/data_rate.h
+++ b/api/units/data_rate.h
@@ -126,7 +126,7 @@
return DataSize::bytes(data_rate_impl::MillibytePerSec(rate) / millihertz);
}
inline constexpr Frequency operator/(const DataRate rate, const DataSize size) {
- return Frequency::millihertz(data_rate_impl::MillibytePerSec(rate) /
+ return Frequency::MilliHertz(data_rate_impl::MillibytePerSec(rate) /
size.bytes());
}
inline constexpr DataRate operator*(const DataSize size,
diff --git a/api/units/data_rate_unittest.cc b/api/units/data_rate_unittest.cc
index 7a3823c..80b9f7b 100644
--- a/api/units/data_rate_unittest.cc
+++ b/api/units/data_rate_unittest.cc
@@ -166,7 +166,7 @@
const int64_t kHertz = 30;
const int64_t kBitsPerSecond = 96000;
const int64_t kBytes = 1200;
- const Frequency freq_a = Frequency::hertz(kHertz);
+ const Frequency freq_a = Frequency::Hertz(kHertz);
const DataRate rate_b = DataRate::bps(kBitsPerSecond);
const DataSize size_c = DataSize::bytes(kBytes);
EXPECT_EQ((freq_a * size_c).bps(), kHertz * kBytes * 8);
diff --git a/api/units/frequency.h b/api/units/frequency.h
index 79b152b..88912c6 100644
--- a/api/units/frequency.h
+++ b/api/units/frequency.h
@@ -26,26 +26,24 @@
class Frequency final : public rtc_units_impl::RelativeUnit<Frequency> {
public:
+ template <typename T>
+ static constexpr Frequency MilliHertz(T value) {
+ static_assert(std::is_arithmetic<T>::value, "");
+ return FromValue(value);
+ }
+ template <typename T>
+ static constexpr Frequency Hertz(T value) {
+ static_assert(std::is_arithmetic<T>::value, "");
+ return FromFraction(1'000, value);
+ }
+ template <typename T>
+ static constexpr Frequency KiloHertz(T value) {
+ static_assert(std::is_arithmetic<T>::value, "");
+ return FromFraction(1'000'000, value);
+ }
+
Frequency() = delete;
- template <int64_t hertz>
- static constexpr Frequency Hertz() {
- return FromFraction(1000, hertz);
- }
- template <typename T>
- static constexpr Frequency kHz(T hertz) {
- static_assert(std::is_arithmetic<T>::value, "");
- return FromFraction(1000000, hertz);
- }
- template <typename T>
- static constexpr Frequency hertz(T hertz) {
- static_assert(std::is_arithmetic<T>::value, "");
- return FromFraction(1000, hertz);
- }
- template <typename T>
- static constexpr Frequency millihertz(T hertz) {
- static_assert(std::is_arithmetic<T>::value, "");
- return FromValue(hertz);
- }
+
template <typename T = int64_t>
constexpr T hertz() const {
return ToFraction<1000, T>();
@@ -67,7 +65,7 @@
RTC_DCHECK_LE(nominator, std::numeric_limits<int64_t>::max() / kKiloPerMicro);
RTC_CHECK(interval.IsFinite());
RTC_CHECK(!interval.IsZero());
- return Frequency::millihertz(nominator * kKiloPerMicro / interval.us());
+ return Frequency::MilliHertz(nominator * kKiloPerMicro / interval.us());
}
inline constexpr TimeDelta operator/(int64_t nominator,
diff --git a/api/units/frequency_unittest.cc b/api/units/frequency_unittest.cc
index 8c0561f..1260c21 100644
--- a/api/units/frequency_unittest.cc
+++ b/api/units/frequency_unittest.cc
@@ -28,29 +28,30 @@
TEST(FrequencyTest, GetBackSameValues) {
const int64_t kValue = 31;
- EXPECT_EQ(Frequency::hertz(kValue).hertz<int64_t>(), kValue);
+ EXPECT_EQ(Frequency::Hertz(kValue).hertz<int64_t>(), kValue);
EXPECT_EQ(Frequency::Zero().hertz<int64_t>(), 0);
}
TEST(FrequencyTest, GetDifferentPrefix) {
const int64_t kValue = 30000;
- EXPECT_EQ(Frequency::millihertz(kValue).hertz<int64_t>(), kValue / 1000);
- EXPECT_EQ(Frequency::hertz(kValue).millihertz(), kValue * 1000);
+ EXPECT_EQ(Frequency::MilliHertz(kValue).hertz<int64_t>(), kValue / 1000);
+ EXPECT_EQ(Frequency::Hertz(kValue).millihertz(), kValue * 1000);
+ EXPECT_EQ(Frequency::KiloHertz(kValue).hertz(), kValue * 1000);
}
TEST(FrequencyTest, IdentityChecks) {
const int64_t kValue = 31;
EXPECT_TRUE(Frequency::Zero().IsZero());
- EXPECT_FALSE(Frequency::hertz(kValue).IsZero());
+ EXPECT_FALSE(Frequency::Hertz(kValue).IsZero());
EXPECT_TRUE(Frequency::PlusInfinity().IsInfinite());
EXPECT_TRUE(Frequency::MinusInfinity().IsInfinite());
EXPECT_FALSE(Frequency::Zero().IsInfinite());
- EXPECT_FALSE(Frequency::hertz(kValue).IsInfinite());
+ EXPECT_FALSE(Frequency::Hertz(kValue).IsInfinite());
EXPECT_FALSE(Frequency::PlusInfinity().IsFinite());
EXPECT_FALSE(Frequency::MinusInfinity().IsFinite());
- EXPECT_TRUE(Frequency::hertz(kValue).IsFinite());
+ EXPECT_TRUE(Frequency::Hertz(kValue).IsFinite());
EXPECT_TRUE(Frequency::Zero().IsFinite());
EXPECT_TRUE(Frequency::PlusInfinity().IsPlusInfinity());
@@ -63,19 +64,19 @@
TEST(FrequencyTest, ComparisonOperators) {
const int64_t kSmall = 42;
const int64_t kLarge = 45;
- const Frequency small = Frequency::hertz(kSmall);
- const Frequency large = Frequency::hertz(kLarge);
+ const Frequency small = Frequency::Hertz(kSmall);
+ const Frequency large = Frequency::Hertz(kLarge);
- EXPECT_EQ(Frequency::Zero(), Frequency::hertz(0));
+ EXPECT_EQ(Frequency::Zero(), Frequency::Hertz(0));
EXPECT_EQ(Frequency::PlusInfinity(), Frequency::PlusInfinity());
- EXPECT_EQ(small, Frequency::hertz(kSmall));
- EXPECT_LE(small, Frequency::hertz(kSmall));
- EXPECT_GE(small, Frequency::hertz(kSmall));
- EXPECT_NE(small, Frequency::hertz(kLarge));
- EXPECT_LE(small, Frequency::hertz(kLarge));
- EXPECT_LT(small, Frequency::hertz(kLarge));
- EXPECT_GE(large, Frequency::hertz(kSmall));
- EXPECT_GT(large, Frequency::hertz(kSmall));
+ EXPECT_EQ(small, Frequency::Hertz(kSmall));
+ EXPECT_LE(small, Frequency::Hertz(kSmall));
+ EXPECT_GE(small, Frequency::Hertz(kSmall));
+ EXPECT_NE(small, Frequency::Hertz(kLarge));
+ EXPECT_LE(small, Frequency::Hertz(kLarge));
+ EXPECT_LT(small, Frequency::Hertz(kLarge));
+ EXPECT_GE(large, Frequency::Hertz(kSmall));
+ EXPECT_GT(large, Frequency::Hertz(kSmall));
EXPECT_LT(Frequency::Zero(), small);
EXPECT_GT(Frequency::PlusInfinity(), large);
@@ -83,11 +84,11 @@
}
TEST(FrequencyTest, Clamping) {
- const Frequency upper = Frequency::hertz(800);
- const Frequency lower = Frequency::hertz(100);
- const Frequency under = Frequency::hertz(100);
- const Frequency inside = Frequency::hertz(500);
- const Frequency over = Frequency::hertz(1000);
+ const Frequency upper = Frequency::Hertz(800);
+ const Frequency lower = Frequency::Hertz(100);
+ const Frequency under = Frequency::Hertz(100);
+ const Frequency inside = Frequency::Hertz(500);
+ const Frequency over = Frequency::Hertz(1000);
EXPECT_EQ(under.Clamped(lower, upper), lower);
EXPECT_EQ(inside.Clamped(lower, upper), inside);
EXPECT_EQ(over.Clamped(lower, upper), upper);
@@ -106,40 +107,40 @@
TEST(FrequencyTest, MathOperations) {
const int64_t kValueA = 457;
const int64_t kValueB = 260;
- const Frequency frequency_a = Frequency::hertz(kValueA);
- const Frequency frequency_b = Frequency::hertz(kValueB);
+ const Frequency frequency_a = Frequency::Hertz(kValueA);
+ const Frequency frequency_b = Frequency::Hertz(kValueB);
EXPECT_EQ((frequency_a + frequency_b).hertz<int64_t>(), kValueA + kValueB);
EXPECT_EQ((frequency_a - frequency_b).hertz<int64_t>(), kValueA - kValueB);
- EXPECT_EQ((Frequency::hertz(kValueA) * kValueB).hertz<int64_t>(),
+ EXPECT_EQ((Frequency::Hertz(kValueA) * kValueB).hertz<int64_t>(),
kValueA * kValueB);
EXPECT_EQ((frequency_b / 10).hertz<int64_t>(), kValueB / 10);
EXPECT_EQ(frequency_b / frequency_a, static_cast<double>(kValueB) / kValueA);
- Frequency mutable_frequency = Frequency::hertz(kValueA);
- mutable_frequency += Frequency::hertz(kValueB);
- EXPECT_EQ(mutable_frequency, Frequency::hertz(kValueA + kValueB));
- mutable_frequency -= Frequency::hertz(kValueB);
- EXPECT_EQ(mutable_frequency, Frequency::hertz(kValueA));
+ Frequency mutable_frequency = Frequency::Hertz(kValueA);
+ mutable_frequency += Frequency::Hertz(kValueB);
+ EXPECT_EQ(mutable_frequency, Frequency::Hertz(kValueA + kValueB));
+ mutable_frequency -= Frequency::Hertz(kValueB);
+ EXPECT_EQ(mutable_frequency, Frequency::Hertz(kValueA));
}
TEST(FrequencyTest, Rounding) {
- const Frequency freq_high = Frequency::hertz(23.976);
+ const Frequency freq_high = Frequency::Hertz(23.976);
EXPECT_EQ(freq_high.hertz(), 24);
- EXPECT_EQ(freq_high.RoundDownTo(Frequency::hertz(1)), Frequency::hertz(23));
- EXPECT_EQ(freq_high.RoundTo(Frequency::hertz(1)), Frequency::hertz(24));
- EXPECT_EQ(freq_high.RoundUpTo(Frequency::hertz(1)), Frequency::hertz(24));
+ EXPECT_EQ(freq_high.RoundDownTo(Frequency::Hertz(1)), Frequency::Hertz(23));
+ EXPECT_EQ(freq_high.RoundTo(Frequency::Hertz(1)), Frequency::Hertz(24));
+ EXPECT_EQ(freq_high.RoundUpTo(Frequency::Hertz(1)), Frequency::Hertz(24));
- const Frequency freq_low = Frequency::hertz(23.4);
+ const Frequency freq_low = Frequency::Hertz(23.4);
EXPECT_EQ(freq_low.hertz(), 23);
- EXPECT_EQ(freq_low.RoundDownTo(Frequency::hertz(1)), Frequency::hertz(23));
- EXPECT_EQ(freq_low.RoundTo(Frequency::hertz(1)), Frequency::hertz(23));
- EXPECT_EQ(freq_low.RoundUpTo(Frequency::hertz(1)), Frequency::hertz(24));
+ EXPECT_EQ(freq_low.RoundDownTo(Frequency::Hertz(1)), Frequency::Hertz(23));
+ EXPECT_EQ(freq_low.RoundTo(Frequency::Hertz(1)), Frequency::Hertz(23));
+ EXPECT_EQ(freq_low.RoundUpTo(Frequency::Hertz(1)), Frequency::Hertz(24));
}
TEST(FrequencyTest, InfinityOperations) {
const double kValue = 267;
- const Frequency finite = Frequency::hertz(kValue);
+ const Frequency finite = Frequency::Hertz(kValue);
EXPECT_TRUE((Frequency::PlusInfinity() + finite).IsPlusInfinity());
EXPECT_TRUE((Frequency::PlusInfinity() - finite).IsPlusInfinity());
EXPECT_TRUE((finite + Frequency::PlusInfinity()).IsPlusInfinity());
@@ -152,9 +153,9 @@
}
TEST(UnitConversionTest, TimeDeltaAndFrequency) {
- EXPECT_EQ(1 / Frequency::hertz(50), TimeDelta::Millis(20));
- EXPECT_EQ(1 / TimeDelta::Millis(20), Frequency::hertz(50));
- EXPECT_EQ(Frequency::kHz(200) * TimeDelta::Millis(2), 400.0);
+ EXPECT_EQ(1 / Frequency::Hertz(50), TimeDelta::Millis(20));
+ EXPECT_EQ(1 / TimeDelta::Millis(20), Frequency::Hertz(50));
+ EXPECT_EQ(Frequency::KiloHertz(200) * TimeDelta::Millis(2), 400.0);
}
} // namespace test
} // namespace webrtc
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 956ac0c..1f0ca33 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -262,7 +262,7 @@
Frequency packet_rate = data_rate / packet_size;
// TOSO(srte): We should not need to round to nearest whole packet per second
// rate here.
- return packet_rate.RoundUpTo(Frequency::hertz(1)) * overhead_per_packet;
+ return packet_rate.RoundUpTo(Frequency::Hertz(1)) * overhead_per_packet;
}
absl::optional<VideoCodecType> GetVideoCodecType(const RtpConfig& config) {
