Replace DataSize and DataRate factories with newer versions
This is search and replace change:
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataSize::Bytes<\(.*\)>()/DataSize::Bytes(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataSize::bytes/DataSize::Bytes/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::BitsPerSec<\(.*\)>()/DataRate::BitsPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::BytesPerSec<\(.*\)>()/DataRate::BytesPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::KilobitsPerSec<\(.*\)>()/DataRate::KilobitsPerSec(\1)/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::bps/DataRate::BitsPerSec/g"
find . -type f \( -name "*.h" -o -name "*.cc" \) | xargs sed -i -e "s/DataRate::kbps/DataRate::KilobitsPerSec/g"
git cl format
Bug: webrtc:9709
Change-Id: I65aaca69474ba038c1fe2dd8dc30d3f8e7b94c29
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168647
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30545}
diff --git a/api/transport/test/feedback_generator_interface.h b/api/transport/test/feedback_generator_interface.h
index bc95751..6e5118c 100644
--- a/api/transport/test/feedback_generator_interface.h
+++ b/api/transport/test/feedback_generator_interface.h
@@ -22,7 +22,7 @@
BuiltInNetworkBehaviorConfig send_link;
BuiltInNetworkBehaviorConfig return_link;
TimeDelta feedback_interval = TimeDelta::Millis(50);
- DataSize feedback_packet_size = DataSize::bytes(20);
+ DataSize feedback_packet_size = DataSize::Bytes(20);
};
virtual ~FeedbackGenerator() = default;
virtual Timestamp Now() = 0;
diff --git a/api/video/video_bitrate_allocator.cc b/api/video/video_bitrate_allocator.cc
index 6ad16c9..8ad5f75 100644
--- a/api/video/video_bitrate_allocator.cc
+++ b/api/video/video_bitrate_allocator.cc
@@ -15,8 +15,8 @@
VideoBitrateAllocationParameters::VideoBitrateAllocationParameters(
uint32_t total_bitrate_bps,
uint32_t framerate)
- : total_bitrate(DataRate::bps(total_bitrate_bps)),
- stable_bitrate(DataRate::bps(total_bitrate_bps)),
+ : total_bitrate(DataRate::BitsPerSec(total_bitrate_bps)),
+ stable_bitrate(DataRate::BitsPerSec(total_bitrate_bps)),
framerate(static_cast<double>(framerate)) {}
VideoBitrateAllocationParameters::VideoBitrateAllocationParameters(
@@ -39,8 +39,8 @@
VideoBitrateAllocation VideoBitrateAllocator::GetAllocation(
uint32_t total_bitrate_bps,
uint32_t framerate) {
- return Allocate({DataRate::bps(total_bitrate_bps),
- DataRate::bps(total_bitrate_bps),
+ return Allocate({DataRate::BitsPerSec(total_bitrate_bps),
+ DataRate::BitsPerSec(total_bitrate_bps),
static_cast<double>(framerate)});
}
diff --git a/api/video_codecs/video_encoder.cc b/api/video_codecs/video_encoder.cc
index 52e2866..cf25987 100644
--- a/api/video_codecs/video_encoder.cc
+++ b/api/video_codecs/video_encoder.cc
@@ -218,7 +218,7 @@
double framerate_fps)
: bitrate(bitrate),
framerate_fps(framerate_fps),
- bandwidth_allocation(DataRate::bps(bitrate.get_sum_bps())) {}
+ bandwidth_allocation(DataRate::BitsPerSec(bitrate.get_sum_bps())) {}
VideoEncoder::RateControlParameters::RateControlParameters(
const VideoBitrateAllocation& bitrate,
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 17ab5d7..9c709d8 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -804,12 +804,12 @@
constexpr int kOverheadPerPacket = 20 + 8 + 10 + 12;
const TimeDelta kMinPacketDuration = TimeDelta::Millis(20);
DataRate max_overhead =
- DataSize::bytes(kOverheadPerPacket) / kMinPacketDuration;
+ DataSize::Bytes(kOverheadPerPacket) / kMinPacketDuration;
priority_bitrate += max_overhead;
} else {
RTC_DCHECK(frame_length_range_);
const DataSize kOverheadPerPacket =
- DataSize::bytes(total_packet_overhead_bytes_);
+ DataSize::Bytes(total_packet_overhead_bytes_);
DataRate max_overhead = kOverheadPerPacket / frame_length_range_->first;
priority_bitrate += max_overhead;
}
@@ -841,8 +841,8 @@
AudioSendStream::TargetAudioBitrateConstraints
AudioSendStream::GetMinMaxBitrateConstraints() const {
TargetAudioBitrateConstraints constraints{
- DataRate::bps(config_.min_bitrate_bps),
- DataRate::bps(config_.max_bitrate_bps)};
+ DataRate::BitsPerSec(config_.min_bitrate_bps),
+ DataRate::BitsPerSec(config_.max_bitrate_bps)};
// If bitrates were explicitly overriden via field trial, use those values.
if (allocation_settings_.min_bitrate)
@@ -856,7 +856,7 @@
if (send_side_bwe_with_overhead_) {
if (use_legacy_overhead_calculation_) {
// OverheadPerPacket = Ipv4(20B) + UDP(8B) + SRTP(10B) + RTP(12)
- const DataSize kOverheadPerPacket = DataSize::bytes(20 + 8 + 10 + 12);
+ const DataSize kOverheadPerPacket = DataSize::Bytes(20 + 8 + 10 + 12);
const TimeDelta kMaxFrameLength =
TimeDelta::Millis(60); // Based on Opus spec
const DataRate kMinOverhead = kOverheadPerPacket / kMaxFrameLength;
@@ -865,7 +865,7 @@
} else {
RTC_DCHECK(frame_length_range_);
const DataSize kOverheadPerPacket =
- DataSize::bytes(total_packet_overhead_bytes_);
+ DataSize::Bytes(total_packet_overhead_bytes_);
constraints.min += kOverheadPerPacket / frame_length_range_->second;
constraints.max += kOverheadPerPacket / frame_length_range_->first;
}
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index 8600a67..e7c6540 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -82,7 +82,7 @@
// TODO(dklee): This mirrors calculation in audio_send_stream.cc, which
// should be made more precise in the future. This can be changed when that
// logic is more accurate.
-const DataSize kOverheadPerPacket = DataSize::bytes(20 + 8 + 10 + 12);
+const DataSize kOverheadPerPacket = DataSize::Bytes(20 + 8 + 10 + 12);
const TimeDelta kMinFrameLength = TimeDelta::Millis(20);
const TimeDelta kMaxFrameLength = TimeDelta::Millis(120);
const DataRate kMinOverheadRate = kOverheadPerPacket / kMaxFrameLength;
@@ -549,11 +549,12 @@
ConfigHelper helper(false, true);
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.channel_send(),
- OnBitrateAllocation(
- Field(&BitrateAllocationUpdate::target_bitrate,
- Eq(DataRate::bps(helper.config().max_bitrate_bps)))));
+ OnBitrateAllocation(Field(
+ &BitrateAllocationUpdate::target_bitrate,
+ Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps)))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(helper.config().max_bitrate_bps + 5000);
+ update.target_bitrate =
+ DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000);
update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(6000);
@@ -565,12 +566,14 @@
ScopedFieldTrials field_trials("WebRTC-Audio-SendSideBwe/Enabled/");
ConfigHelper helper(true, true);
auto send_stream = helper.CreateAudioSendStream();
- EXPECT_CALL(*helper.channel_send(),
- OnBitrateAllocation(Field(
- &BitrateAllocationUpdate::target_bitrate,
- Eq(DataRate::bps(helper.config().max_bitrate_bps - 5000)))));
+ EXPECT_CALL(
+ *helper.channel_send(),
+ OnBitrateAllocation(Field(
+ &BitrateAllocationUpdate::target_bitrate,
+ Eq(DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000)))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(helper.config().max_bitrate_bps - 5000);
+ update.target_bitrate =
+ DataRate::BitsPerSec(helper.config().max_bitrate_bps - 5000);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
}
@@ -584,9 +587,9 @@
EXPECT_CALL(
*helper.channel_send(),
OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate,
- Eq(DataRate::kbps(6)))));
+ Eq(DataRate::KilobitsPerSec(6)))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::kbps(1);
+ update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
}
@@ -600,9 +603,9 @@
EXPECT_CALL(
*helper.channel_send(),
OnBitrateAllocation(Field(&BitrateAllocationUpdate::target_bitrate,
- Eq(DataRate::kbps(64)))));
+ Eq(DataRate::KilobitsPerSec(64)))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::kbps(128);
+ update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
}
@@ -617,7 +620,7 @@
EXPECT_CALL(*helper.channel_send(), CallEncoder(_)).Times(1);
send_stream->OnOverheadChanged(kOverheadPerPacket.bytes<size_t>());
const DataRate bitrate =
- DataRate::bps(helper.config().max_bitrate_bps) + kMaxOverheadRate;
+ DataRate::BitsPerSec(helper.config().max_bitrate_bps) + kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(),
OnBitrateAllocation(Field(
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
@@ -637,12 +640,12 @@
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.channel_send(), CallEncoder(_)).Times(1);
send_stream->OnOverheadChanged(kOverheadPerPacket.bytes<size_t>());
- const DataRate bitrate = DataRate::kbps(6) + kMinOverheadRate;
+ const DataRate bitrate = DataRate::KilobitsPerSec(6) + kMinOverheadRate;
EXPECT_CALL(*helper.channel_send(),
OnBitrateAllocation(Field(
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::kbps(1);
+ update.target_bitrate = DataRate::KilobitsPerSec(1);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
}
@@ -657,12 +660,12 @@
auto send_stream = helper.CreateAudioSendStream();
EXPECT_CALL(*helper.channel_send(), CallEncoder(_)).Times(1);
send_stream->OnOverheadChanged(kOverheadPerPacket.bytes<size_t>());
- const DataRate bitrate = DataRate::kbps(64) + kMaxOverheadRate;
+ const DataRate bitrate = DataRate::KilobitsPerSec(64) + kMaxOverheadRate;
EXPECT_CALL(*helper.channel_send(),
OnBitrateAllocation(Field(
&BitrateAllocationUpdate::target_bitrate, Eq(bitrate))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::kbps(128);
+ update.target_bitrate = DataRate::KilobitsPerSec(128);
helper.worker()->SendTask([&] { send_stream->OnBitrateUpdated(update); },
RTC_FROM_HERE);
}
@@ -675,7 +678,8 @@
OnBitrateAllocation(Field(&BitrateAllocationUpdate::bwe_period,
Eq(TimeDelta::Millis(5000)))));
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(helper.config().max_bitrate_bps + 5000);
+ update.target_bitrate =
+ DataRate::BitsPerSec(helper.config().max_bitrate_bps + 5000);
update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Millis(50);
update.bwe_period = TimeDelta::Millis(5000);
diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc
index 681b100..8e2006d 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -404,8 +404,9 @@
uint32_t allocated_stable_target_rate =
stable_bitrate_allocation[config.observer];
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(allocated_bitrate);
- update.stable_target_bitrate = DataRate::bps(allocated_stable_target_rate);
+ update.target_bitrate = DataRate::BitsPerSec(allocated_bitrate);
+ update.stable_target_bitrate =
+ DataRate::BitsPerSec(allocated_stable_target_rate);
update.packet_loss_ratio = last_fraction_loss_ / 256.0;
update.round_trip_time = TimeDelta::Millis(last_rtt_);
update.bwe_period = TimeDelta::Millis(last_bwe_period_ms_);
@@ -469,8 +470,9 @@
uint32_t allocated_stable_bitrate =
stable_bitrate_allocation[config.observer];
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(allocated_bitrate);
- update.stable_target_bitrate = DataRate::bps(allocated_stable_bitrate);
+ update.target_bitrate = DataRate::BitsPerSec(allocated_bitrate);
+ update.stable_target_bitrate =
+ DataRate::BitsPerSec(allocated_stable_bitrate);
update.packet_loss_ratio = last_fraction_loss_ / 256.0;
update.round_trip_time = TimeDelta::Millis(last_rtt_);
update.bwe_period = TimeDelta::Millis(last_bwe_period_ms_);
@@ -501,13 +503,14 @@
uint32_t stream_padding = config.config.pad_up_bitrate_bps;
if (config.config.enforce_min_bitrate) {
limits.min_allocatable_rate +=
- DataRate::bps(config.config.min_bitrate_bps);
+ DataRate::BitsPerSec(config.config.min_bitrate_bps);
} else if (config.allocated_bitrate_bps == 0) {
stream_padding =
std::max(config.MinBitrateWithHysteresis(), stream_padding);
}
- limits.max_padding_rate += DataRate::bps(stream_padding);
- limits.max_allocatable_rate += DataRate::bps(config.config.max_bitrate_bps);
+ limits.max_padding_rate += DataRate::BitsPerSec(stream_padding);
+ limits.max_allocatable_rate +=
+ DataRate::BitsPerSec(config.config.max_bitrate_bps);
}
if (limits.min_allocatable_rate == current_limits_.min_allocatable_rate &&
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index e15f913..1479a47 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -30,19 +30,19 @@
uint32_t max_padding_rate_bps,
uint32_t max_allocatable_rate_bps) {
return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
- DataRate::bps(min_allocatable_rate_bps)),
+ DataRate::BitsPerSec(min_allocatable_rate_bps)),
Field(&BitrateAllocationLimits::max_allocatable_rate,
- DataRate::bps(max_allocatable_rate_bps)),
+ DataRate::BitsPerSec(max_allocatable_rate_bps)),
Field(&BitrateAllocationLimits::max_padding_rate,
- DataRate::bps(max_padding_rate_bps)));
+ DataRate::BitsPerSec(max_padding_rate_bps)));
}
auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
uint32_t max_padding_rate_bps) {
return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
- DataRate::bps(min_allocatable_rate_bps)),
+ DataRate::BitsPerSec(min_allocatable_rate_bps)),
Field(&BitrateAllocationLimits::max_padding_rate,
- DataRate::bps(max_padding_rate_bps)));
+ DataRate::BitsPerSec(max_padding_rate_bps)));
}
class MockLimitObserver : public BitrateAllocator::LimitObserver {
@@ -89,7 +89,7 @@
// The timestamp is just for log output, keeping it fixed just means fewer log
// messages in the test.
msg.at_time = Timestamp::Seconds(10000);
- msg.target_rate = DataRate::bps(target_bitrate_bps);
+ msg.target_rate = DataRate::BitsPerSec(target_bitrate_bps);
msg.stable_target_rate = msg.target_rate;
msg.network_estimate.bandwidth = msg.target_rate;
msg.network_estimate.loss_rate_ratio = fraction_loss / 255.0;
diff --git a/call/call.cc b/call/call.cc
index 880c4bb..fba783f 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -1351,7 +1351,7 @@
packet.GetHeader(&header);
ReceivedPacket packet_msg;
- packet_msg.size = DataSize::bytes(packet.payload_size());
+ packet_msg.size = DataSize::Bytes(packet.payload_size());
packet_msg.receive_time = Timestamp::Millis(packet.arrival_time_ms());
if (header.extension.hasAbsoluteSendTime) {
packet_msg.send_time = header.extension.GetAbsoluteSendTimestamp();
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index e80713c..50c34f9 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -40,12 +40,14 @@
Clock* clock) {
TargetRateConstraints msg;
msg.at_time = Timestamp::Millis(clock->TimeInMilliseconds());
- msg.min_data_rate =
- min_bitrate_bps >= 0 ? DataRate::bps(min_bitrate_bps) : DataRate::Zero();
- msg.max_data_rate = max_bitrate_bps > 0 ? DataRate::bps(max_bitrate_bps)
- : DataRate::Infinity();
+ msg.min_data_rate = min_bitrate_bps >= 0
+ ? DataRate::BitsPerSec(min_bitrate_bps)
+ : DataRate::Zero();
+ msg.max_data_rate = max_bitrate_bps > 0
+ ? DataRate::BitsPerSec(max_bitrate_bps)
+ : DataRate::Infinity();
if (start_bitrate_bps > 0)
- msg.starting_rate = DataRate::bps(start_bitrate_bps);
+ msg.starting_rate = DataRate::BitsPerSec(start_bitrate_bps);
return msg;
}
@@ -114,8 +116,8 @@
initial_config_.key_value_config = trials;
RTC_DCHECK(bitrate_config.start_bitrate_bps > 0);
- pacer()->SetPacingRates(DataRate::bps(bitrate_config.start_bitrate_bps),
- DataRate::Zero());
+ pacer()->SetPacingRates(
+ DataRate::BitsPerSec(bitrate_config.start_bitrate_bps), DataRate::Zero());
if (!use_task_queue_pacer_) {
process_thread_->Start();
@@ -426,7 +428,7 @@
}
pacer()->SetTransportOverhead(
- DataSize::bytes(transport_overhead_bytes_per_packet));
+ DataSize::Bytes(transport_overhead_bytes_per_packet));
// TODO(holmer): Call AudioRtpSenders when they have been moved to
// RtpTransportControllerSend.
@@ -448,7 +450,7 @@
void RtpTransportControllerSend::OnReceivedEstimatedBitrate(uint32_t bitrate) {
RemoteBitrateReport msg;
msg.receive_time = Timestamp::Millis(clock_->TimeInMilliseconds());
- msg.bandwidth = DataRate::bps(bitrate);
+ msg.bandwidth = DataRate::BitsPerSec(bitrate);
task_queue_.PostTask([this, msg]() {
RTC_DCHECK_RUN_ON(&task_queue_);
if (controller_)
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 1f0ca33..42a03c0 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -695,9 +695,9 @@
int framerate) {
// Substract overhead from bitrate.
rtc::CritScope lock(&crit_);
- DataSize packet_overhead = DataSize::bytes(
+ DataSize packet_overhead = DataSize::Bytes(
overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_);
- DataSize max_total_packet_size = DataSize::bytes(
+ DataSize max_total_packet_size = DataSize::Bytes(
rtp_config_.max_packet_size + transport_overhead_bytes_per_packet_);
uint32_t payload_bitrate_bps = update.target_bitrate.bps();
if (send_side_bwe_with_overhead_ && has_packet_feedback_) {
@@ -742,8 +742,8 @@
// make sense to use different packet rates for different overhead
// calculations.
DataRate encoder_overhead_rate = CalculateOverheadRate(
- DataRate::bps(encoder_target_rate_bps_),
- max_total_packet_size - DataSize::bytes(overhead_bytes_per_packet_),
+ DataRate::BitsPerSec(encoder_target_rate_bps_),
+ max_total_packet_size - DataSize::Bytes(overhead_bytes_per_packet_),
packet_overhead);
encoder_overhead_rate_bps = std::min(
encoder_overhead_rate.bps<uint32_t>(),
@@ -754,7 +754,7 @@
const uint32_t media_rate = encoder_target_rate_bps_ +
encoder_overhead_rate_bps +
packetization_rate_bps;
- RTC_DCHECK_GE(update.target_bitrate, DataRate::bps(media_rate));
+ RTC_DCHECK_GE(update.target_bitrate, DataRate::BitsPerSec(media_rate));
protection_bitrate_bps_ = update.target_bitrate.bps() - media_rate;
}
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index 74e92a5..9f4aef4 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -502,10 +502,10 @@
test::Scenario s(test_info_);
test::CallClientConfig call_conf;
// Keeping the bitrate fixed to avoid RTX due to probing.
- call_conf.transport.rates.max_rate = DataRate::kbps(300);
- call_conf.transport.rates.start_rate = DataRate::kbps(300);
+ call_conf.transport.rates.max_rate = DataRate::KilobitsPerSec(300);
+ call_conf.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
test::NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(300);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(300);
auto send_node = s.CreateSimulationNode(net_conf);
auto* route = s.CreateRoutes(s.CreateClient("send", call_conf), {send_node},
s.CreateClient("return", call_conf),
diff --git a/call/simulated_network.cc b/call/simulated_network.cc
index 200d5ed..0412129 100644
--- a/call/simulated_network.cc
+++ b/call/simulated_network.cc
@@ -34,7 +34,7 @@
constexpr TimeDelta kWindow = TimeDelta::Millis(100);
constexpr TimeDelta kDelayThreshold = TimeDelta::Millis(5);
constexpr TimeDelta kDropCountMemory = TimeDelta::Millis(1600);
- constexpr DataSize kMaxPacketSize = DataSize::Bytes<1500>();
+ constexpr DataSize kMaxPacketSize = DataSize::Bytes(1500);
// Compensates for process interval in simulation; not part of standard CoDel.
TimeDelta queuing_time = now - enqueing_time - kDefaultProcessDelay;
@@ -193,8 +193,8 @@
codel_controller_.DropDequeuedPacket(
Timestamp::Micros(time_us),
Timestamp::Micros(capacity_link_.front().packet.send_time_us),
- DataSize::bytes(capacity_link_.front().packet.size),
- DataSize::bytes(queue_size_bytes_))) {
+ DataSize::Bytes(capacity_link_.front().packet.size),
+ DataSize::Bytes(queue_size_bytes_))) {
PacketInfo dropped = capacity_link_.front();
capacity_link_.pop();
queue_size_bytes_ -= dropped.packet.size;
diff --git a/call/simulated_network_unittest.cc b/call/simulated_network_unittest.cc
index 0d098f7..a4545e5 100644
--- a/call/simulated_network_unittest.cc
+++ b/call/simulated_network_unittest.cc
@@ -26,8 +26,8 @@
TEST(SimulatedNetworkTest, CodelDoesNothingAtCapacity) {
const TimeDelta kRuntime = TimeDelta::Seconds(30);
- DataRate link_capacity = DataRate::kbps(1000);
- const DataSize packet_size = DataSize::bytes(1000);
+ DataRate link_capacity = DataRate::KilobitsPerSec(1000);
+ const DataSize packet_size = DataSize::Bytes(1000);
SimulatedNetwork::Config config;
config.codel_active_queue_management = true;
@@ -80,8 +80,8 @@
const TimeDelta kRuntime = TimeDelta::Seconds(30);
const TimeDelta kCheckInterval = TimeDelta::Millis(2000);
- DataRate link_capacity = DataRate::kbps(1000);
- const DataSize rough_packet_size = DataSize::bytes(1500);
+ DataRate link_capacity = DataRate::KilobitsPerSec(1000);
+ const DataSize rough_packet_size = DataSize::Bytes(1500);
const double overload_rate = 1.5;
SimulatedNetwork::Config config;
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index 6a8c64c..4016f84 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -2407,14 +2407,14 @@
if (proto.has_link_capacity_lower_kbps()) {
base_link_capacity_lower_kbps = proto.link_capacity_lower_kbps();
base_event.link_capacity_lower =
- DataRate::kbps(proto.link_capacity_lower_kbps());
+ DataRate::KilobitsPerSec(proto.link_capacity_lower_kbps());
}
absl::optional<uint64_t> base_link_capacity_upper_kbps;
if (proto.has_link_capacity_upper_kbps()) {
base_link_capacity_upper_kbps = proto.link_capacity_upper_kbps();
base_event.link_capacity_upper =
- DataRate::kbps(proto.link_capacity_upper_kbps());
+ DataRate::KilobitsPerSec(proto.link_capacity_upper_kbps());
}
remote_estimate_events_.push_back(base_event);
@@ -2452,10 +2452,10 @@
event.timestamp_ms = *timestamp_ms_values[i];
if (link_capacity_lower_kbps_values[i])
event.link_capacity_lower =
- DataRate::kbps(*link_capacity_lower_kbps_values[i]);
+ DataRate::KilobitsPerSec(*link_capacity_lower_kbps_values[i]);
if (link_capacity_upper_kbps_values[i])
event.link_capacity_upper =
- DataRate::kbps(*link_capacity_upper_kbps_values[i]);
+ DataRate::KilobitsPerSec(*link_capacity_upper_kbps_values[i]);
remote_estimate_events_.push_back(event);
}
return ParseStatus::Success();
diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
index 2d0e34a..2a41f6d2 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.cc
@@ -358,8 +358,8 @@
std::unique_ptr<RtcEventRemoteEstimate> EventGenerator::NewRemoteEstimate() {
return std::make_unique<RtcEventRemoteEstimate>(
- DataRate::kbps(prng_.Rand(0, 100000)),
- DataRate::kbps(prng_.Rand(0, 100000)));
+ DataRate::KilobitsPerSec(prng_.Rand(0, 100000)),
+ DataRate::KilobitsPerSec(prng_.Rand(0, 100000)));
}
std::unique_ptr<RtcEventRtcpPacketIncoming>
diff --git a/media/engine/simulcast.cc b/media/engine/simulcast.cc
index 94609ff..5fc6a99 100644
--- a/media/engine/simulcast.cc
+++ b/media/engine/simulcast.cc
@@ -45,16 +45,16 @@
// Limits for legacy conference screensharing mode. Currently used for the
// lower of the two simulcast streams.
constexpr webrtc::DataRate kScreenshareDefaultTl0Bitrate =
- webrtc::DataRate::kbps(200);
+ webrtc::DataRate::KilobitsPerSec(200);
constexpr webrtc::DataRate kScreenshareDefaultTl1Bitrate =
- webrtc::DataRate::kbps(1000);
+ webrtc::DataRate::KilobitsPerSec(1000);
// Min/max bitrate for the higher one of the two simulcast stream used for
// screen content.
constexpr webrtc::DataRate kScreenshareHighStreamMinBitrate =
- webrtc::DataRate::kbps(600);
+ webrtc::DataRate::KilobitsPerSec(600);
constexpr webrtc::DataRate kScreenshareHighStreamMaxBitrate =
- webrtc::DataRate::kbps(1250);
+ webrtc::DataRate::KilobitsPerSec(1250);
} // namespace
@@ -78,24 +78,28 @@
// These tables describe from which resolution we can use how many
// simulcast layers at what bitrates (maximum, target, and minimum).
// Important!! Keep this table from high resolution to low resolution.
-// clang-format off
constexpr const SimulcastFormat kSimulcastFormats[] = {
- {1920, 1080, 3, webrtc::DataRate::kbps(5000), webrtc::DataRate::kbps(4000),
- webrtc::DataRate::kbps(800)},
- {1280, 720, 3, webrtc::DataRate::kbps(2500), webrtc::DataRate::kbps(2500),
- webrtc::DataRate::kbps(600)},
- {960, 540, 3, webrtc::DataRate::kbps(1200), webrtc::DataRate::kbps(1200),
- webrtc::DataRate::kbps(350)},
- {640, 360, 2, webrtc::DataRate::kbps(700), webrtc::DataRate::kbps(500),
- webrtc::DataRate::kbps(150)},
- {480, 270, 2, webrtc::DataRate::kbps(450), webrtc::DataRate::kbps(350),
- webrtc::DataRate::kbps(150)},
- {320, 180, 1, webrtc::DataRate::kbps(200), webrtc::DataRate::kbps(150),
- webrtc::DataRate::kbps(30)},
- {0, 0, 1, webrtc::DataRate::kbps(200), webrtc::DataRate::kbps(150),
- webrtc::DataRate::kbps(30)}
-};
-// clang-format on
+ {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(5000),
+ webrtc::DataRate::KilobitsPerSec(4000),
+ webrtc::DataRate::KilobitsPerSec(800)},
+ {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(2500),
+ webrtc::DataRate::KilobitsPerSec(2500),
+ webrtc::DataRate::KilobitsPerSec(600)},
+ {960, 540, 3, webrtc::DataRate::KilobitsPerSec(1200),
+ webrtc::DataRate::KilobitsPerSec(1200),
+ webrtc::DataRate::KilobitsPerSec(350)},
+ {640, 360, 2, webrtc::DataRate::KilobitsPerSec(700),
+ webrtc::DataRate::KilobitsPerSec(500),
+ webrtc::DataRate::KilobitsPerSec(150)},
+ {480, 270, 2, webrtc::DataRate::KilobitsPerSec(450),
+ webrtc::DataRate::KilobitsPerSec(350),
+ webrtc::DataRate::KilobitsPerSec(150)},
+ {320, 180, 1, webrtc::DataRate::KilobitsPerSec(200),
+ webrtc::DataRate::KilobitsPerSec(150),
+ webrtc::DataRate::KilobitsPerSec(30)},
+ {0, 0, 1, webrtc::DataRate::KilobitsPerSec(200),
+ webrtc::DataRate::KilobitsPerSec(150),
+ webrtc::DataRate::KilobitsPerSec(30)}};
const int kMaxScreenshareSimulcastLayers = 2;
@@ -222,7 +226,7 @@
total_max_bitrate_bps += layers[s].target_bitrate_bps;
}
total_max_bitrate_bps += layers.back().max_bitrate_bps;
- return webrtc::DataRate::bps(total_max_bitrate_bps);
+ return webrtc::DataRate::BitsPerSec(total_max_bitrate_bps);
}
size_t LimitSimulcastLayerCount(int width,
diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc
index 1ec4a56..03768de 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -508,14 +508,14 @@
// Assign link allocation proportionally to spatial layer allocation.
if (parameters.bandwidth_allocation != DataRate::Zero()) {
stream_parameters.bandwidth_allocation =
- DataRate::bps((parameters.bandwidth_allocation.bps() *
- stream_parameters.bitrate.get_sum_bps()) /
- parameters.bitrate.get_sum_bps());
+ DataRate::BitsPerSec((parameters.bandwidth_allocation.bps() *
+ stream_parameters.bitrate.get_sum_bps()) /
+ parameters.bitrate.get_sum_bps());
// Make sure we don't allocate bandwidth lower than target bitrate.
if (stream_parameters.bandwidth_allocation.bps() <
stream_parameters.bitrate.get_sum_bps()) {
stream_parameters.bandwidth_allocation =
- DataRate::bps(stream_parameters.bitrate.get_sum_bps());
+ DataRate::BitsPerSec(stream_parameters.bitrate.get_sum_bps());
}
}
diff --git a/media/engine/simulcast_encoder_adapter_unittest.cc b/media/engine/simulcast_encoder_adapter_unittest.cc
index bbd6ade..04ea92e 100644
--- a/media/engine/simulcast_encoder_adapter_unittest.cc
+++ b/media/engine/simulcast_encoder_adapter_unittest.cc
@@ -1275,10 +1275,11 @@
kVideoCodecVP8);
codec_.numberOfSimulcastStreams = 3;
const DataRate target_bitrate =
- DataRate::kbps(codec_.simulcastStream[0].targetBitrate +
- codec_.simulcastStream[1].targetBitrate +
- codec_.simulcastStream[2].minBitrate);
- const DataRate bandwidth_allocation = target_bitrate + DataRate::kbps(600);
+ DataRate::KilobitsPerSec(codec_.simulcastStream[0].targetBitrate +
+ codec_.simulcastStream[1].targetBitrate +
+ codec_.simulcastStream[2].minBitrate);
+ const DataRate bandwidth_allocation =
+ target_bitrate + DataRate::KilobitsPerSec(600);
rate_allocator_.reset(new SimulcastRateAllocator(codec_));
EXPECT_EQ(0, adapter_->InitEncode(&codec_, kSettings));
@@ -1357,7 +1358,8 @@
// Make sure we have bitrate for all layers.
DataRate max_bitrate = DataRate::Zero();
for (int i = 0; i < 3; ++i) {
- max_bitrate += DataRate::kbps(codec_.simulcastStream[i].maxBitrate);
+ max_bitrate +=
+ DataRate::KilobitsPerSec(codec_.simulcastStream[i].maxBitrate);
}
const auto rate_settings = VideoEncoder::RateControlParameters(
rate_allocator_->Allocate(
diff --git a/media/engine/simulcast_unittest.cc b/media/engine/simulcast_unittest.cc
index e5c4c89..0ce388a 100644
--- a/media/engine/simulcast_unittest.cc
+++ b/media/engine/simulcast_unittest.cc
@@ -63,7 +63,7 @@
streams[1].target_bitrate_bps = 200000;
streams[2].max_bitrate_bps = 400000;
- const webrtc::DataRate one_bps = webrtc::DataRate::bps(1);
+ const webrtc::DataRate one_bps = webrtc::DataRate::BitsPerSec(1);
// No bitrate above the total max to give to the highest stream.
const webrtc::DataRate max_total_bitrate =
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index e1ec173..1b8e137 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -3349,7 +3349,7 @@
// No application-configured maximum for the largest layer.
// If there is bitrate leftover, give it to the largest layer.
BoostMaxSimulcastLayer(
- webrtc::DataRate::bps(encoder_config.max_bitrate_bps), &layers);
+ webrtc::DataRate::BitsPerSec(encoder_config.max_bitrate_bps), &layers);
}
return layers;
}
diff --git a/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc b/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc
index 3280858..04ee64e 100644
--- a/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc
+++ b/modules/congestion_controller/bbr/bandwidth_sampler_unittest.cc
@@ -36,7 +36,7 @@
static_assert((kRegularPacketSizeBytes & 31) == 0,
"kRegularPacketSizeBytes has to be five times divisible by 2");
-const DataSize kRegularPacketSize = DataSize::bytes(kRegularPacketSizeBytes);
+const DataSize kRegularPacketSize = DataSize::Bytes(kRegularPacketSizeBytes);
// A test fixture with utility methods for BandwidthSampler tests.
class BandwidthSamplerTest : public ::testing::Test {
diff --git a/modules/congestion_controller/bbr/bbr_network_controller.cc b/modules/congestion_controller/bbr/bbr_network_controller.cc
index e707f7a..250fddb 100644
--- a/modules/congestion_controller/bbr/bbr_network_controller.cc
+++ b/modules/congestion_controller/bbr/bbr_network_controller.cc
@@ -35,11 +35,11 @@
// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
// additional 8 bytes. This is a total overhead of 48 bytes. Ethernet's
// max packet size is 1500 bytes, 1500 - 48 = 1452.
-const DataSize kMaxPacketSize = DataSize::Bytes<1452>();
+const DataSize kMaxPacketSize = DataSize::Bytes(1452);
// Default maximum packet size used in the Linux TCP implementation.
// Used in QUIC for congestion window computations in bytes.
-constexpr DataSize kDefaultTCPMSS = DataSize::Bytes<1460>();
+constexpr DataSize kDefaultTCPMSS = DataSize::Bytes(1460);
// Constants based on TCP defaults.
constexpr DataSize kMaxSegmentSize = kDefaultTCPMSS;
@@ -184,7 +184,7 @@
last_sent_packet_(0),
current_round_trip_end_(0),
max_bandwidth_(kBandwidthWindowSize, DataRate::Zero(), 0),
- default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)),
+ default_bandwidth_(DataRate::KilobitsPerSec(kInitialBandwidthKbps)),
max_ack_height_(kBandwidthWindowSize, DataSize::Zero(), 0),
aggregation_epoch_start_time_(),
aggregation_epoch_bytes_(DataSize::Zero()),
diff --git a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc b/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc
index 92fb5ec..cbf0987 100644
--- a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc
+++ b/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc
@@ -32,7 +32,7 @@
namespace test {
namespace {
-const DataRate kInitialBitrate = DataRate::kbps(60);
+const DataRate kInitialBitrate = DataRate::KilobitsPerSec(60);
const Timestamp kDefaultStartTime = Timestamp::Millis(10000000);
constexpr double kDataRateMargin = 0.3;
@@ -51,9 +51,12 @@
int max_data_rate_kbps = 5 * kInitialBitrate.kbps()) {
NetworkControllerConfig config;
config.constraints.at_time = kDefaultStartTime;
- config.constraints.min_data_rate = DataRate::kbps(min_data_rate_kbps);
- config.constraints.max_data_rate = DataRate::kbps(max_data_rate_kbps);
- config.constraints.starting_rate = DataRate::kbps(starting_bandwidth_kbps);
+ config.constraints.min_data_rate =
+ DataRate::KilobitsPerSec(min_data_rate_kbps);
+ config.constraints.max_data_rate =
+ DataRate::KilobitsPerSec(max_data_rate_kbps);
+ config.constraints.starting_rate =
+ DataRate::KilobitsPerSec(starting_bandwidth_kbps);
return config;
}
@@ -105,7 +108,7 @@
EXPECT_TRUE(update.pacer_config.has_value());
EXPECT_TRUE(update.congestion_window.has_value());
- DataRate new_bitrate = DataRate::bps(200000);
+ DataRate new_bitrate = DataRate::BitsPerSec(200000);
update = controller_->OnNetworkRouteChange(
CreateRouteChange(kDefaultStartTime, new_bitrate));
EXPECT_THAT(*update.target_rate, TargetRateCloseTo(new_bitrate));
@@ -121,18 +124,18 @@
Scenario s("bbr_unit/updates_rate", false);
CallClientConfig config;
config.transport.cc_factory = &factory;
- config.transport.rates.min_rate = DataRate::kbps(10);
- config.transport.rates.max_rate = DataRate::kbps(1500);
- config.transport.rates.start_rate = DataRate::kbps(300);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(1500);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(500);
+ c->bandwidth = DataRate::KilobitsPerSec(500);
c->delay = TimeDelta::Millis(100);
c->loss_rate = 0.0;
});
auto ret_net = s.CreateMutableSimulationNode(
[](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); });
auto* client = s.CreateClient("send", config);
- const DataSize kOverhead = DataSize::bytes(38); // IPV4 + UDP + SRTP
+ const DataSize kOverhead = DataSize::Bytes(38); // IPV4 + UDP + SRTP
auto routes = s.CreateRoutes(client, {send_net->node()}, kOverhead,
s.CreateClient("recv", CallClientConfig()),
{ret_net->node()}, kOverhead);
@@ -142,7 +145,7 @@
EXPECT_NEAR(client->send_bandwidth().kbps(), 450, 100);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(800);
+ c->bandwidth = DataRate::KilobitsPerSec(800);
c->delay = TimeDelta::Millis(100);
});
@@ -150,7 +153,7 @@
EXPECT_NEAR(client->send_bandwidth().kbps(), 750, 150);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(200);
+ c->bandwidth = DataRate::KilobitsPerSec(200);
c->delay = TimeDelta::Millis(200);
});
ret_net->UpdateConfig(
diff --git a/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc b/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc
index de0a2b4..c9177ed 100644
--- a/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc
+++ b/modules/congestion_controller/bbr/data_transfer_tracker_unittest.cc
@@ -26,7 +26,7 @@
class DataTransferTrackerForTest : public DataTransferTracker {
public:
void AddSample(int bytes, int send_time_ms, int ack_time_ms) {
- DataTransferTracker::AddSample(DataSize::bytes(bytes),
+ DataTransferTracker::AddSample(DataSize::Bytes(bytes),
Timestamp::Millis(send_time_ms),
Timestamp::Millis(ack_time_ms));
}
diff --git a/modules/congestion_controller/bbr/windowed_filter_unittest.cc b/modules/congestion_controller/bbr/windowed_filter_unittest.cc
index 5b36e86..d537806 100644
--- a/modules/congestion_controller/bbr/windowed_filter_unittest.cc
+++ b/modules/congestion_controller/bbr/windowed_filter_unittest.cc
@@ -59,7 +59,7 @@
// Third best = 600 bps, recorded at 100ms
void InitializeMaxFilter() {
int64_t now_ms = 0;
- DataRate bw_sample = DataRate::bps(1000);
+ DataRate bw_sample = DataRate::BitsPerSec(1000);
for (int i = 0; i < 5; ++i) {
windowed_max_bw_.Update(bw_sample, now_ms);
RTC_LOG(LS_VERBOSE) << "i: " << i << " sample: " << ToString(bw_sample)
@@ -69,11 +69,11 @@
<< ToString(windowed_max_bw_.GetSecondBest()) << " "
<< ToString(windowed_max_bw_.GetThirdBest());
now_ms += 25;
- bw_sample = DataRate::bps(bw_sample.bps() - 100);
+ bw_sample = DataRate::BitsPerSec(bw_sample.bps() - 100);
}
- EXPECT_EQ(DataRate::bps(900), windowed_max_bw_.GetBest());
- EXPECT_EQ(DataRate::bps(700), windowed_max_bw_.GetSecondBest());
- EXPECT_EQ(DataRate::bps(600), windowed_max_bw_.GetThirdBest());
+ EXPECT_EQ(DataRate::BitsPerSec(900), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(700), windowed_max_bw_.GetSecondBest());
+ EXPECT_EQ(DataRate::BitsPerSec(600), windowed_max_bw_.GetThirdBest());
}
protected:
@@ -135,15 +135,15 @@
TEST_F(WindowedFilterTest, MonotonicallyDecreasingMax) {
int64_t now_ms = 0;
- DataRate bw_sample = DataRate::bps(1000);
+ DataRate bw_sample = DataRate::BitsPerSec(1000);
windowed_max_bw_.Update(bw_sample, now_ms);
- EXPECT_EQ(DataRate::bps(1000), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(1000), windowed_max_bw_.GetBest());
// Gradually decrease the bw samples and ensure the windowed max bw starts
// decreasing.
for (int i = 0; i < 6; ++i) {
now_ms += 25;
- bw_sample = DataRate::bps(bw_sample.bps() - 100);
+ bw_sample = DataRate::BitsPerSec(bw_sample.bps() - 100);
windowed_max_bw_.Update(bw_sample, now_ms);
RTC_LOG(LS_VERBOSE) << "i: " << i << " sample: " << bw_sample.bps()
<< " maxs: "
@@ -152,11 +152,11 @@
<< windowed_max_bw_.GetSecondBest().bps() << " "
<< windowed_max_bw_.GetThirdBest().bps();
if (i < 3) {
- EXPECT_EQ(DataRate::bps(1000), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(1000), windowed_max_bw_.GetBest());
} else if (i == 3) {
- EXPECT_EQ(DataRate::bps(900), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(900), windowed_max_bw_.GetBest());
} else if (i < 6) {
- EXPECT_EQ(DataRate::bps(700), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(700), windowed_max_bw_.GetBest());
}
}
}
@@ -181,13 +181,13 @@
InitializeMaxFilter();
// BW sample higher than the third-choice max sets that, but nothing else.
DataRate bw_sample =
- DataRate::bps(windowed_max_bw_.GetThirdBest().bps() + 50);
+ DataRate::BitsPerSec(windowed_max_bw_.GetThirdBest().bps() + 50);
// Latest sample was recorded at 100ms.
int64_t now_ms = 101;
windowed_max_bw_.Update(bw_sample, now_ms);
EXPECT_EQ(bw_sample, windowed_max_bw_.GetThirdBest());
- EXPECT_EQ(DataRate::bps(700), windowed_max_bw_.GetSecondBest());
- EXPECT_EQ(DataRate::bps(900), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(700), windowed_max_bw_.GetSecondBest());
+ EXPECT_EQ(DataRate::BitsPerSec(900), windowed_max_bw_.GetBest());
}
TEST_F(WindowedFilterTest, SampleChangesSecondBestMin) {
@@ -212,14 +212,14 @@
// BW sample higher than the second-choice max sets that and also
// the third-choice max.
DataRate bw_sample =
- DataRate::bps(windowed_max_bw_.GetSecondBest().bps() + 50);
+ DataRate::BitsPerSec(windowed_max_bw_.GetSecondBest().bps() + 50);
// Latest sample was recorded at 100ms.
int64_t now_ms = 101;
windowed_max_bw_.Update(bw_sample, now_ms);
EXPECT_EQ(bw_sample, windowed_max_bw_.GetThirdBest());
EXPECT_EQ(bw_sample, windowed_max_bw_.GetSecondBest());
- EXPECT_EQ(DataRate::bps(900), windowed_max_bw_.GetBest());
+ EXPECT_EQ(DataRate::BitsPerSec(900), windowed_max_bw_.GetBest());
}
TEST_F(WindowedFilterTest, SampleChangesAllMins) {
@@ -242,7 +242,8 @@
InitializeMaxFilter();
// BW sample higher than the first-choice max sets that and also
// the second and third-choice maxs.
- DataRate bw_sample = DataRate::bps(windowed_max_bw_.GetBest().bps() + 50);
+ DataRate bw_sample =
+ DataRate::BitsPerSec(windowed_max_bw_.GetBest().bps() + 50);
// Latest sample was recorded at 100ms.
int64_t now_ms = 101;
windowed_max_bw_.Update(bw_sample, now_ms);
@@ -268,7 +269,7 @@
InitializeMaxFilter();
DataRate old_third_best = windowed_max_bw_.GetThirdBest();
DataRate old_second_best = windowed_max_bw_.GetSecondBest();
- DataRate bw_sample = DataRate::bps(old_third_best.bps() - 50);
+ DataRate bw_sample = DataRate::BitsPerSec(old_third_best.bps() - 50);
// Best max sample was recorded at 25ms, so expiry time is 124ms.
int64_t now_ms = 125;
windowed_max_bw_.Update(bw_sample, now_ms);
@@ -292,7 +293,7 @@
TEST_F(WindowedFilterTest, ExpireSecondBestMax) {
InitializeMaxFilter();
DataRate old_third_best = windowed_max_bw_.GetThirdBest();
- DataRate bw_sample = DataRate::bps(old_third_best.bps() - 50);
+ DataRate bw_sample = DataRate::BitsPerSec(old_third_best.bps() - 50);
// Second best max sample was recorded at 75ms, so expiry time is 174ms.
int64_t now_ms = 175;
windowed_max_bw_.Update(bw_sample, now_ms);
@@ -319,7 +320,7 @@
TEST_F(WindowedFilterTest, ExpireAllMaxs) {
InitializeMaxFilter();
DataRate bw_sample =
- DataRate::bps(windowed_max_bw_.GetThirdBest().bps() - 50);
+ DataRate::BitsPerSec(windowed_max_bw_.GetThirdBest().bps() - 50);
// Third best max sample was recorded at 100ms, so expiry time is 199ms.
int64_t now_ms = 200;
windowed_max_bw_.Update(bw_sample, now_ms);
diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
index 2e98deb..9031c5d 100644
--- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
+++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
@@ -65,14 +65,14 @@
packet_feedback_vector[0].sent_packet.send_time =
Timestamp::Millis(kFirstSendTimeMs);
packet_feedback_vector[0].sent_packet.sequence_number = kSequenceNumber;
- packet_feedback_vector[0].sent_packet.size = DataSize::bytes(kPayloadSize);
+ packet_feedback_vector[0].sent_packet.size = DataSize::Bytes(kPayloadSize);
packet_feedback_vector[1].receive_time =
Timestamp::Millis(kFirstArrivalTimeMs + 10);
packet_feedback_vector[1].sent_packet.send_time =
Timestamp::Millis(kFirstSendTimeMs + 10);
packet_feedback_vector[1].sent_packet.sequence_number = kSequenceNumber;
packet_feedback_vector[1].sent_packet.size =
- DataSize::bytes(kPayloadSize + 10);
+ DataSize::Bytes(kPayloadSize + 10);
return packet_feedback_vector;
}
@@ -124,7 +124,7 @@
TEST(TestAcknowledgedBitrateEstimator, ReturnBitrate) {
auto states = CreateTestStates();
- absl::optional<DataRate> return_value = DataRate::kbps(42);
+ absl::optional<DataRate> return_value = DataRate::KilobitsPerSec(42);
EXPECT_CALL(*states.mock_bitrate_estimator, bitrate())
.Times(1)
.WillOnce(Return(return_value));
diff --git a/modules/congestion_controller/goog_cc/bitrate_estimator.cc b/modules/congestion_controller/goog_cc/bitrate_estimator.cc
index 2be08d5..09b214a 100644
--- a/modules/congestion_controller/goog_cc/bitrate_estimator.cc
+++ b/modules/congestion_controller/goog_cc/bitrate_estimator.cc
@@ -148,12 +148,12 @@
absl::optional<DataRate> BitrateEstimator::bitrate() const {
if (bitrate_estimate_kbps_ < 0.f)
return absl::nullopt;
- return DataRate::kbps(bitrate_estimate_kbps_);
+ return DataRate::KilobitsPerSec(bitrate_estimate_kbps_);
}
absl::optional<DataRate> BitrateEstimator::PeekRate() const {
if (current_window_ms_ > 0)
- return DataSize::bytes(sum_) / TimeDelta::Millis(current_window_ms_);
+ return DataSize::Bytes(sum_) / TimeDelta::Millis(current_window_ms_);
return absl::nullopt;
}
diff --git a/modules/congestion_controller/goog_cc/congestion_window_pushback_controller_unittest.cc b/modules/congestion_controller/goog_cc/congestion_window_pushback_controller_unittest.cc
index 37b7233..62dde02 100644
--- a/modules/congestion_controller/goog_cc/congestion_window_pushback_controller_unittest.cc
+++ b/modules/congestion_controller/goog_cc/congestion_window_pushback_controller_unittest.cc
@@ -37,20 +37,20 @@
TEST_F(CongestionWindowPushbackControllerTest, FullCongestionWindow) {
cwnd_controller_->UpdateOutstandingData(100000);
- cwnd_controller_->SetDataWindow(DataSize::bytes(50000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(50000));
uint32_t bitrate_bps = 80000;
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
EXPECT_EQ(72000u, bitrate_bps);
- cwnd_controller_->SetDataWindow(DataSize::bytes(50000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(50000));
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
EXPECT_EQ(static_cast<uint32_t>(72000 * 0.9 * 0.9), bitrate_bps);
}
TEST_F(CongestionWindowPushbackControllerTest, NormalCongestionWindow) {
cwnd_controller_->UpdateOutstandingData(199999);
- cwnd_controller_->SetDataWindow(DataSize::bytes(200000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(200000));
uint32_t bitrate_bps = 80000;
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
@@ -59,13 +59,13 @@
TEST_F(CongestionWindowPushbackControllerTest, LowBitrate) {
cwnd_controller_->UpdateOutstandingData(100000);
- cwnd_controller_->SetDataWindow(DataSize::bytes(50000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(50000));
uint32_t bitrate_bps = 35000;
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
EXPECT_EQ(static_cast<uint32_t>(35000 * 0.9), bitrate_bps);
- cwnd_controller_->SetDataWindow(DataSize::bytes(20000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(20000));
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
EXPECT_EQ(30000u, bitrate_bps);
}
@@ -94,7 +94,7 @@
cwnd_controller_.reset(
new CongestionWindowPushbackController(&field_trial_config_));
cwnd_controller_->UpdateOutstandingData(1e8); // Large number
- cwnd_controller_->SetDataWindow(DataSize::bytes(50000));
+ cwnd_controller_->SetDataWindow(DataSize::Bytes(50000));
uint32_t bitrate_bps = 80000;
bitrate_bps = cwnd_controller_->UpdateTargetBitrate(bitrate_bps);
diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc
index 9d8d226..7860c3d 100644
--- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc
+++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc
@@ -174,8 +174,8 @@
}
TEST_F(DelayBasedBweTest, TestInitialOveruse) {
- const DataRate kStartBitrate = DataRate::kbps(300);
- const DataRate kInitialCapacity = DataRate::kbps(200);
+ const DataRate kStartBitrate = DataRate::KilobitsPerSec(300);
+ const DataRate kInitialCapacity = DataRate::KilobitsPerSec(200);
const uint32_t kDummySsrc = 0;
// High FPS to ensure that we send a lot of packets in a short time.
const int kFps = 90;
@@ -222,8 +222,8 @@
// This test subsumes and improves DelayBasedBweTest.TestInitialOveruse above.
TEST_F(DelayBasedBweTestWithBackoffTimeoutExperiment, TestInitialOveruse) {
- const DataRate kStartBitrate = DataRate::kbps(300);
- const DataRate kInitialCapacity = DataRate::kbps(200);
+ const DataRate kStartBitrate = DataRate::KilobitsPerSec(300);
+ const DataRate kInitialCapacity = DataRate::KilobitsPerSec(200);
const uint32_t kDummySsrc = 0;
// High FPS to ensure that we send a lot of packets in a short time.
const int kFps = 90;
diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc
index 5d3c30b..14bac1e 100644
--- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc
+++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc
@@ -54,7 +54,7 @@
PacketResult packet;
packet.sent_packet.send_time =
Timestamp::Micros(time_now_us + kSendSideOffsetUs);
- packet.sent_packet.size = DataSize::bytes(payload_size);
+ packet.sent_packet.size = DataSize::Bytes(payload_size);
packets->push_back(packet);
}
next_rtp_time_ = time_now_us + (1000000 + fps_ / 2) / fps_;
@@ -196,7 +196,7 @@
packet.receive_time =
Timestamp::Millis(arrival_time_ms + arrival_time_offset_ms_);
packet.sent_packet.send_time = Timestamp::Millis(send_time_ms);
- packet.sent_packet.size = DataSize::bytes(payload_size);
+ packet.sent_packet.size = DataSize::Bytes(payload_size);
packet.sent_packet.pacing_info = pacing_info;
if (packet.sent_packet.pacing_info.probe_cluster_id !=
PacedPacketInfo::kNotAProbe)
diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
index 3fb5ded..12d18e1 100644
--- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
+++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc
@@ -375,7 +375,7 @@
TimeDelta min_feedback_max_rtt = TimeDelta::Millis(
*std::min_element(feedback_max_rtts_.begin(), feedback_max_rtts_.end()));
- const DataSize kMinCwnd = DataSize::bytes(2 * 1500);
+ const DataSize kMinCwnd = DataSize::Bytes(2 * 1500);
TimeDelta time_window =
min_feedback_max_rtt +
TimeDelta::Millis(
@@ -607,7 +607,7 @@
loss_based_target_rate.bps());
pushback_rate = std::max<int64_t>(bandwidth_estimation_->GetMinBitrate(),
pushback_rate);
- pushback_target_rate = DataRate::bps(pushback_rate);
+ pushback_target_rate = DataRate::BitsPerSec(pushback_rate);
if (rate_control_settings_.UseCongestionWindowDropFrameOnly()) {
cwnd_reduce_ratio = static_cast<double>(loss_based_target_rate.bps() -
pushback_target_rate.bps()) /
diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
index 77305de..1083214 100644
--- a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
+++ b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
@@ -56,7 +56,7 @@
}
const uint32_t kInitialBitrateKbps = 60;
-const DataRate kInitialBitrate = DataRate::kbps(kInitialBitrateKbps);
+const DataRate kInitialBitrate = DataRate::KilobitsPerSec(kInitialBitrateKbps);
const float kDefaultPacingRate = 2.5f;
CallClient* CreateVideoSendingClient(
@@ -78,11 +78,11 @@
Scenario s("googcc_unit/target_capacity" + test_name, false);
CallClientConfig config;
config.transport.cc_factory = &factory;
- config.transport.rates.min_rate = DataRate::kbps(10);
- config.transport.rates.max_rate = DataRate::kbps(1500);
- config.transport.rates.start_rate = DataRate::kbps(300);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(1500);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(500);
+ c->bandwidth = DataRate::KilobitsPerSec(500);
c->delay = TimeDelta::Millis(100);
c->loss_rate = 0.0;
});
@@ -100,7 +100,7 @@
EXPECT_NEAR(client->target_rate().kbps(), 450, 100);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(800);
+ c->bandwidth = DataRate::KilobitsPerSec(800);
c->delay = TimeDelta::Millis(100);
});
@@ -110,7 +110,7 @@
EXPECT_NEAR(client->target_rate().kbps(), 750, 150);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(100);
+ c->bandwidth = DataRate::KilobitsPerSec(100);
c->delay = TimeDelta::Millis(200);
});
ret_net->UpdateConfig(
@@ -155,9 +155,12 @@
int max_data_rate_kbps = 5 * kInitialBitrateKbps) {
NetworkControllerConfig config;
config.constraints.at_time = current_time_;
- config.constraints.min_data_rate = DataRate::kbps(min_data_rate_kbps);
- config.constraints.max_data_rate = DataRate::kbps(max_data_rate_kbps);
- config.constraints.starting_rate = DataRate::kbps(starting_bandwidth_kbps);
+ config.constraints.min_data_rate =
+ DataRate::KilobitsPerSec(min_data_rate_kbps);
+ config.constraints.max_data_rate =
+ DataRate::KilobitsPerSec(max_data_rate_kbps);
+ config.constraints.starting_rate =
+ DataRate::KilobitsPerSec(starting_bandwidth_kbps);
config.event_log = &event_log_;
return config;
}
@@ -179,7 +182,7 @@
PacketResult packet_result;
packet_result.sent_packet = SentPacket();
packet_result.sent_packet.send_time = Timestamp::Millis(send_time_ms);
- packet_result.sent_packet.size = DataSize::bytes(payload_size);
+ packet_result.sent_packet.size = DataSize::Bytes(payload_size);
packet_result.sent_packet.pacing_info = pacing_info;
packet_result.receive_time = Timestamp::Millis(arrival_time_ms);
return packet_result;
@@ -263,7 +266,7 @@
Scenario s("googcc_unit/cwnd_on_delay", false);
auto send_net =
s.CreateMutableSimulationNode([=](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(1000);
+ c->bandwidth = DataRate::KilobitsPerSec(1000);
c->delay = TimeDelta::Millis(100);
});
auto ret_net = s.CreateSimulationNode(
@@ -271,9 +274,9 @@
CallClientConfig config;
config.transport.cc_factory = &factory;
// Start high so bandwidth drop has max effect.
- config.transport.rates.start_rate = DataRate::kbps(300);
- config.transport.rates.max_rate = DataRate::kbps(2000);
- config.transport.rates.min_rate = DataRate::kbps(10);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(2000);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
auto* client = CreateVideoSendingClient(&s, std::move(config),
{send_net->node()}, {ret_net});
@@ -298,7 +301,7 @@
Scenario s("googcc_unit/cwnd_on_delay", false);
auto send_net =
s.CreateMutableSimulationNode([=](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(1000);
+ c->bandwidth = DataRate::KilobitsPerSec(1000);
c->delay = TimeDelta::Millis(100);
});
auto ret_net = s.CreateSimulationNode(
@@ -306,9 +309,9 @@
CallClientConfig config;
config.transport.cc_factory = &factory;
// Start high so bandwidth drop has max effect.
- config.transport.rates.start_rate = DataRate::kbps(300);
- config.transport.rates.max_rate = DataRate::kbps(2000);
- config.transport.rates.min_rate = DataRate::kbps(10);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(2000);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
auto* client = CreateVideoSendingClient(&s, std::move(config),
{send_net->node()}, {ret_net});
@@ -325,7 +328,7 @@
TEST_F(GoogCcNetworkControllerTest, OnNetworkRouteChanged) {
NetworkControlUpdate update;
- DataRate new_bitrate = DataRate::bps(200000);
+ DataRate new_bitrate = DataRate::BitsPerSec(200000);
update = controller_->OnNetworkRouteChange(CreateRouteChange(new_bitrate));
EXPECT_EQ(update.target_rate->target_rate, new_bitrate);
EXPECT_EQ(update.pacer_config->data_rate(), new_bitrate * kDefaultPacingRate);
@@ -333,7 +336,7 @@
// If the bitrate is reset to -1, the new starting bitrate will be
// the minimum default bitrate.
- const DataRate kDefaultMinBitrate = DataRate::kbps(5);
+ const DataRate kDefaultMinBitrate = DataRate::KilobitsPerSec(5);
update = controller_->OnNetworkRouteChange(CreateRouteChange());
EXPECT_EQ(update.target_rate->target_rate, kDefaultMinBitrate);
EXPECT_NEAR(update.pacer_config->data_rate().bps<double>(),
@@ -384,15 +387,15 @@
Scenario s("googcc_unit/padding_limited", false);
auto send_net =
s.CreateMutableSimulationNode([=](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(1000);
+ c->bandwidth = DataRate::KilobitsPerSec(1000);
c->delay = TimeDelta::Millis(100);
});
auto ret_net = s.CreateSimulationNode(
[](NetworkSimulationConfig* c) { c->delay = TimeDelta::Millis(100); });
CallClientConfig config;
// Start high so bandwidth drop has max effect.
- config.transport.rates.start_rate = DataRate::kbps(1000);
- config.transport.rates.max_rate = DataRate::kbps(2000);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(1000);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(2000);
auto* client = s.CreateClient("send", config);
auto* route =
s.CreateRoutes(client, {send_net->node()},
@@ -417,13 +420,13 @@
// controller backs off until it reaches the minimum configured bitrate. This
// allows the RTT to recover faster than the regular control mechanism would
// achieve.
- const DataRate kBandwidthFloor = DataRate::kbps(50);
+ const DataRate kBandwidthFloor = DataRate::KilobitsPerSec(50);
ScopedFieldTrials trial("WebRTC-Bwe-MaxRttLimit/limit:2s,floor:" +
std::to_string(kBandwidthFloor.kbps()) + "kbps/");
// In the test case, we limit the capacity and add a cross traffic packet
// burst that blocks media from being sent. This causes the RTT to quickly
// increase above the threshold in the trial.
- const DataRate kLinkCapacity = DataRate::kbps(100);
+ const DataRate kLinkCapacity = DataRate::KilobitsPerSec(100);
const TimeDelta kBufferBloatDuration = TimeDelta::Seconds(10);
Scenario s("googcc_unit/limit_trial", false);
auto send_net = s.CreateSimulationNode([=](NetworkSimulationConfig* c) {
@@ -438,7 +441,7 @@
auto* client = CreateVideoSendingClient(&s, config, {send_net}, {ret_net});
// Run for a few seconds to allow the controller to stabilize.
s.RunFor(TimeDelta::Seconds(10));
- const DataSize kBloatPacketSize = DataSize::bytes(1000);
+ const DataSize kBloatPacketSize = DataSize::Bytes(1000);
const int kBloatPacketCount =
static_cast<int>(kBufferBloatDuration * kLinkCapacity / kBloatPacketSize);
// This will cause the RTT to be large for a while.
@@ -459,7 +462,7 @@
CallClientConfig config;
config.transport.cc_factory = &factory;
NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(500);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(500);
net_conf.delay = TimeDelta::Millis(100);
auto send_net = s.CreateSimulationNode(net_conf);
auto ret_net = s.CreateSimulationNode(net_conf);
@@ -502,11 +505,11 @@
ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
Scenario s("googcc_unit/high_loss_channel", false);
CallClientConfig config;
- config.transport.rates.min_rate = DataRate::kbps(10);
- config.transport.rates.max_rate = DataRate::kbps(1500);
- config.transport.rates.start_rate = DataRate::kbps(300);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(1500);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
auto send_net = s.CreateSimulationNode([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(2000);
+ c->bandwidth = DataRate::KilobitsPerSec(2000);
c->delay = TimeDelta::Millis(200);
c->loss_rate = 0.1;
});
@@ -523,7 +526,7 @@
DataRate AverageBitrateAfterCrossInducedLoss(std::string name) {
Scenario s(name, false);
NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(1000);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(1000);
net_conf.delay = TimeDelta::Millis(100);
// Short queue length means that we'll induce loss when sudden TCP traffic
// spikes are induced. This corresponds to ca 200 ms for a packet size of 1000
@@ -550,7 +553,7 @@
s.net()->StopCrossTraffic(tcp_traffic);
s.RunFor(TimeDelta::Seconds(20));
}
- return DataSize::bytes(video->receive()
+ return DataSize::Bytes(video->receive()
->GetStats()
.rtp_stats.packet_counter.TotalBytes()) /
s.TimeSinceStart();
@@ -562,7 +565,7 @@
// trial, we have worse behavior.
DataRate average_bitrate =
AverageBitrateAfterCrossInducedLoss("googcc_unit/no_cross_loss_based");
- RTC_DCHECK_LE(average_bitrate, DataRate::kbps(650));
+ RTC_DCHECK_LE(average_bitrate, DataRate::KilobitsPerSec(650));
}
TEST_F(GoogCcNetworkControllerTest,
@@ -572,19 +575,19 @@
ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
DataRate average_bitrate =
AverageBitrateAfterCrossInducedLoss("googcc_unit/cross_loss_based");
- RTC_DCHECK_GE(average_bitrate, DataRate::kbps(750));
+ RTC_DCHECK_GE(average_bitrate, DataRate::KilobitsPerSec(750));
}
TEST_F(GoogCcNetworkControllerTest, LossBasedEstimatorCapsRateAtModerateLoss) {
ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
Scenario s("googcc_unit/moderate_loss_channel", false);
CallClientConfig config;
- config.transport.rates.min_rate = DataRate::kbps(10);
- config.transport.rates.max_rate = DataRate::kbps(5000);
- config.transport.rates.start_rate = DataRate::kbps(1000);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(5000);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(1000);
NetworkSimulationConfig network;
- network.bandwidth = DataRate::kbps(2000);
+ network.bandwidth = DataRate::KilobitsPerSec(2000);
network.delay = TimeDelta::Millis(100);
// 3% loss rate is in the moderate loss rate region at 2000 kbps, limiting the
// bitrate increase.
@@ -599,8 +602,9 @@
s.RunFor(TimeDelta::Seconds(1));
// This increase in capacity would cause the target bitrate to increase to
// over 4000 kbps without LossBasedControl.
- send_net->UpdateConfig(
- [](NetworkSimulationConfig* c) { c->bandwidth = DataRate::kbps(5000); });
+ send_net->UpdateConfig([](NetworkSimulationConfig* c) {
+ c->bandwidth = DataRate::KilobitsPerSec(5000);
+ });
s.RunFor(TimeDelta::Seconds(20));
// Using LossBasedControl, the bitrate will not increase over 2500 kbps since
// we have detected moderate loss.
@@ -608,8 +612,8 @@
}
TEST_F(GoogCcNetworkControllerTest, MaintainsLowRateInSafeResetTrial) {
- const DataRate kLinkCapacity = DataRate::kbps(200);
- const DataRate kStartRate = DataRate::kbps(300);
+ const DataRate kLinkCapacity = DataRate::KilobitsPerSec(200);
+ const DataRate kStartRate = DataRate::KilobitsPerSec(300);
ScopedFieldTrials trial("WebRTC-Bwe-SafeResetOnRouteChange/Enabled/");
Scenario s("googcc_unit/safe_reset_low");
@@ -635,8 +639,8 @@
}
TEST_F(GoogCcNetworkControllerTest, CutsHighRateInSafeResetTrial) {
- const DataRate kLinkCapacity = DataRate::kbps(1000);
- const DataRate kStartRate = DataRate::kbps(300);
+ const DataRate kLinkCapacity = DataRate::KilobitsPerSec(1000);
+ const DataRate kStartRate = DataRate::KilobitsPerSec(300);
ScopedFieldTrials trial("WebRTC-Bwe-SafeResetOnRouteChange/Enabled/");
Scenario s("googcc_unit/safe_reset_high_cut");
@@ -665,9 +669,9 @@
ScopedFieldTrials trial(
"WebRTC-Bwe-SafeResetOnRouteChange/Enabled,ack/"
"WebRTC-SendSideBwe-WithOverhead/Enabled/");
- const DataRate kInitialLinkCapacity = DataRate::kbps(200);
- const DataRate kNewLinkCapacity = DataRate::kbps(800);
- const DataRate kStartRate = DataRate::kbps(300);
+ const DataRate kInitialLinkCapacity = DataRate::KilobitsPerSec(200);
+ const DataRate kNewLinkCapacity = DataRate::KilobitsPerSec(800);
+ const DataRate kStartRate = DataRate::KilobitsPerSec(300);
Scenario s("googcc_unit/safe_reset_high_detect");
auto* initial_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) {
@@ -709,8 +713,8 @@
"WebRTC-Video-Pacing/factor:1.0/"
"WebRTC-AddPacingToCongestionWindowPushback/Enabled/");
- const DataRate kLinkCapacity = DataRate::kbps(1000);
- const DataRate kStartRate = DataRate::kbps(1000);
+ const DataRate kLinkCapacity = DataRate::KilobitsPerSec(1000);
+ const DataRate kStartRate = DataRate::KilobitsPerSec(1000);
Scenario s("googcc_unit/pacing_buffer_buildup");
auto* net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) {
@@ -735,13 +739,13 @@
ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
Scenario s("googcc_unit/no_toggling");
auto* send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(2000);
+ c->bandwidth = DataRate::KilobitsPerSec(2000);
c->loss_rate = 0.2;
c->delay = TimeDelta::Millis(10);
});
auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
- c->transport.rates.start_rate = DataRate::kbps(300);
+ c->transport.rates.start_rate = DataRate::KilobitsPerSec(300);
});
auto* route = s.CreateRoutes(
client, {send_net}, s.CreateClient("return", CallClientConfig()),
@@ -759,7 +763,9 @@
if (bandwidth_history.size() >= window / step)
bandwidth_history.pop();
bandwidth_history.push(client->send_bandwidth());
- EXPECT_LT(CountBandwidthDips(bandwidth_history, DataRate::kbps(100)), 2);
+ EXPECT_LT(
+ CountBandwidthDips(bandwidth_history, DataRate::KilobitsPerSec(100)),
+ 2);
}
}
@@ -767,12 +773,12 @@
ScopedFieldTrials trial("WebRTC-Bwe-MaxRttLimit/limit:2s/");
Scenario s("googcc_unit/rttbackoff_video_stop");
auto* send_net = s.CreateSimulationNode([&](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(2000);
+ c->bandwidth = DataRate::KilobitsPerSec(2000);
c->delay = TimeDelta::Millis(100);
});
auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
- c->transport.rates.start_rate = DataRate::kbps(1000);
+ c->transport.rates.start_rate = DataRate::KilobitsPerSec(1000);
});
auto* route = s.CreateRoutes(
client, {send_net}, s.CreateClient("return", CallClientConfig()),
@@ -812,10 +818,10 @@
TEST_F(GoogCcNetworkControllerTest, IsFairToTCP) {
Scenario s("googcc_unit/tcp_fairness");
NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(1000);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(1000);
net_conf.delay = TimeDelta::Millis(50);
auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
- c->transport.rates.start_rate = DataRate::kbps(1000);
+ c->transport.rates.start_rate = DataRate::KilobitsPerSec(1000);
});
auto send_net = {s.CreateSimulationNode(net_conf)};
auto ret_net = {s.CreateSimulationNode(net_conf)};
diff --git a/modules/congestion_controller/goog_cc/link_capacity_estimator.cc b/modules/congestion_controller/goog_cc/link_capacity_estimator.cc
index e37d8d8..9fd537a 100644
--- a/modules/congestion_controller/goog_cc/link_capacity_estimator.cc
+++ b/modules/congestion_controller/goog_cc/link_capacity_estimator.cc
@@ -18,14 +18,14 @@
DataRate LinkCapacityEstimator::UpperBound() const {
if (estimate_kbps_.has_value())
- return DataRate::kbps(estimate_kbps_.value() +
- 3 * deviation_estimate_kbps());
+ return DataRate::KilobitsPerSec(estimate_kbps_.value() +
+ 3 * deviation_estimate_kbps());
return DataRate::Infinity();
}
DataRate LinkCapacityEstimator::LowerBound() const {
if (estimate_kbps_.has_value())
- return DataRate::kbps(
+ return DataRate::KilobitsPerSec(
std::max(0.0, estimate_kbps_.value() - 3 * deviation_estimate_kbps()));
return DataRate::Zero();
}
@@ -65,7 +65,7 @@
}
DataRate LinkCapacityEstimator::estimate() const {
- return DataRate::kbps(*estimate_kbps_);
+ return DataRate::KilobitsPerSec(*estimate_kbps_);
}
double LinkCapacityEstimator::deviation_estimate_kbps() const {
diff --git a/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc b/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc
index af05a8ff..1d2aab8 100644
--- a/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc
+++ b/modules/congestion_controller/goog_cc/loss_based_bandwidth_estimation.cc
@@ -83,9 +83,11 @@
loss_window("loss_win", TimeDelta::Millis(800)),
loss_max_window("loss_max_win", TimeDelta::Millis(800)),
acknowledged_rate_max_window("ackrate_max_win", TimeDelta::Millis(800)),
- increase_offset("incr_offset", DataRate::bps(1000)),
- loss_bandwidth_balance_increase("balance_incr", DataRate::kbps(0.5)),
- loss_bandwidth_balance_decrease("balance_decr", DataRate::kbps(4)),
+ increase_offset("incr_offset", DataRate::BitsPerSec(1000)),
+ loss_bandwidth_balance_increase("balance_incr",
+ DataRate::KilobitsPerSec(0.5)),
+ loss_bandwidth_balance_decrease("balance_decr",
+ DataRate::KilobitsPerSec(4)),
loss_bandwidth_balance_exponent("exponent", 0.5),
allow_resets("resets", false),
decrease_interval("decr_intvl", TimeDelta::Millis(300)),
diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc
index 5170195..a52c8e3 100644
--- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc
+++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc
@@ -94,7 +94,7 @@
packet_feedback.sent_packet.pacing_info.probe_cluster_min_probes *
kMinReceivedProbesRatio;
DataSize min_size =
- DataSize::bytes(
+ DataSize::Bytes(
packet_feedback.sent_packet.pacing_info.probe_cluster_min_bytes) *
kMinReceivedBytesRatio;
if (cluster->num_probes < min_probes || cluster->size_total < min_size)
diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc
index 0da194a..6b4146d 100644
--- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc
+++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc
@@ -39,7 +39,7 @@
PacketResult feedback;
feedback.sent_packet.send_time =
kReferenceTime + TimeDelta::Millis(send_time_ms);
- feedback.sent_packet.size = DataSize::bytes(size_bytes);
+ feedback.sent_packet.size = DataSize::Bytes(size_bytes);
feedback.sent_packet.pacing_info =
PacedPacketInfo(probe_cluster_id, min_probes, min_bytes);
feedback.receive_time = kReferenceTime + TimeDelta::Millis(arrival_time_ms);
diff --git a/modules/congestion_controller/goog_cc/probe_controller.cc b/modules/congestion_controller/goog_cc/probe_controller.cc
index 084de18..c921bd9 100644
--- a/modules/congestion_controller/goog_cc/probe_controller.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller.cc
@@ -209,14 +209,15 @@
if (!config_.first_allocation_probe_scale)
return std::vector<ProbeClusterConfig>();
- DataRate first_probe_rate = DataRate::bps(max_total_allocated_bitrate) *
- config_.first_allocation_probe_scale.Value();
+ DataRate first_probe_rate =
+ DataRate::BitsPerSec(max_total_allocated_bitrate) *
+ config_.first_allocation_probe_scale.Value();
DataRate probe_cap = config_.allocation_probe_max.Get();
first_probe_rate = std::min(first_probe_rate, probe_cap);
std::vector<int64_t> probes = {first_probe_rate.bps()};
if (config_.second_allocation_probe_scale) {
DataRate second_probe_rate =
- DataRate::bps(max_total_allocated_bitrate) *
+ DataRate::BitsPerSec(max_total_allocated_bitrate) *
config_.second_allocation_probe_scale.Value();
second_probe_rate = std::min(second_probe_rate, probe_cap);
if (second_probe_rate > first_probe_rate)
@@ -425,7 +426,8 @@
ProbeClusterConfig config;
config.at_time = Timestamp::Millis(now_ms);
- config.target_data_rate = DataRate::bps(rtc::dchecked_cast<int>(bitrate));
+ config.target_data_rate =
+ DataRate::BitsPerSec(rtc::dchecked_cast<int>(bitrate));
config.target_duration = TimeDelta::Millis(kMinProbeDurationMs);
config.target_probe_count = kMinProbePacketsSent;
config.id = next_probe_cluster_id_;
diff --git a/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc b/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc
index a94c70f..e5b1b96 100644
--- a/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc
+++ b/modules/congestion_controller/goog_cc/robust_throughput_estimator.cc
@@ -73,7 +73,7 @@
Timestamp max_send_time = window_[0].sent_packet.send_time;
Timestamp min_recv_time = window_[0].receive_time;
Timestamp max_recv_time = window_[0].receive_time;
- DataSize data_size = DataSize::bytes(0);
+ DataSize data_size = DataSize::Bytes(0);
for (const auto& packet : window_) {
min_send_time = std::min(min_send_time, packet.sent_packet.send_time);
max_send_time = std::max(max_send_time, packet.sent_packet.send_time);
diff --git a/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc b/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc
index 45a3f25..d2e01d3 100644
--- a/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc
+++ b/modules/congestion_controller/goog_cc/robust_throughput_estimator_unittest.cc
@@ -45,7 +45,7 @@
FieldTrialBasedConfig field_trial_config;
RobustThroughputEstimatorSettings settings(&field_trial_config);
RobustThroughputEstimator throughput_estimator(settings);
- DataSize packet_size(DataSize::bytes(1000));
+ DataSize packet_size(DataSize::Bytes(1000));
Timestamp send_clock(Timestamp::Millis(100000));
Timestamp recv_clock(Timestamp::Millis(10000));
TimeDelta send_increment(TimeDelta::Millis(10));
@@ -75,7 +75,7 @@
FieldTrialBasedConfig field_trial_config;
RobustThroughputEstimatorSettings settings(&field_trial_config);
RobustThroughputEstimator throughput_estimator(settings);
- DataSize packet_size(DataSize::bytes(1000));
+ DataSize packet_size(DataSize::Bytes(1000));
Timestamp send_clock(Timestamp::Millis(100000));
Timestamp recv_clock(Timestamp::Millis(10000));
TimeDelta send_increment(TimeDelta::Millis(10));
@@ -124,7 +124,7 @@
FieldTrialBasedConfig field_trial_config;
RobustThroughputEstimatorSettings settings(&field_trial_config);
RobustThroughputEstimator throughput_estimator(settings);
- DataSize packet_size(DataSize::bytes(1000));
+ DataSize packet_size(DataSize::Bytes(1000));
Timestamp send_clock(Timestamp::Millis(100000));
Timestamp recv_clock(Timestamp::Millis(10000));
TimeDelta send_increment(TimeDelta::Millis(10));
@@ -148,7 +148,7 @@
FieldTrialBasedConfig field_trial_config;
RobustThroughputEstimatorSettings settings(&field_trial_config);
RobustThroughputEstimator throughput_estimator(settings);
- DataSize packet_size(DataSize::bytes(1000));
+ DataSize packet_size(DataSize::Bytes(1000));
Timestamp send_clock(Timestamp::Millis(100000));
Timestamp recv_clock(Timestamp::Millis(10000));
TimeDelta send_increment(TimeDelta::Millis(20));
diff --git a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc
index 86e6208..7ebef6c7 100644
--- a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc
+++ b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation.cc
@@ -32,7 +32,7 @@
constexpr TimeDelta kStartPhase = TimeDelta::Millis(2000);
constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis(20000);
constexpr int kLimitNumPackets = 20;
-constexpr DataRate kDefaultMaxBitrate = DataRate::BitsPerSec<1000000000>();
+constexpr DataRate kDefaultMaxBitrate = DataRate::BitsPerSec(1000000000);
constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis(10000);
constexpr TimeDelta kRtcEventLogPeriod = TimeDelta::Millis(5000);
// Expecting that RTCP feedback is sent uniformly within [0.5, 1.5]s intervals.
@@ -149,14 +149,14 @@
}
DataRate LinkCapacityTracker::estimate() const {
- return DataRate::bps(capacity_estimate_bps_);
+ return DataRate::BitsPerSec(capacity_estimate_bps_);
}
RttBasedBackoff::RttBasedBackoff()
: rtt_limit_("limit", TimeDelta::Seconds(3)),
drop_fraction_("fraction", 0.8),
drop_interval_("interval", TimeDelta::Seconds(1)),
- bandwidth_floor_("floor", DataRate::kbps(5)),
+ bandwidth_floor_("floor", DataRate::KilobitsPerSec(5)),
// By initializing this to plus infinity, we make sure that we never
// trigger rtt backoff unless packet feedback is enabled.
last_propagation_rtt_update_(Timestamp::PlusInfinity()),
@@ -191,7 +191,7 @@
current_target_(DataRate::Zero()),
last_logged_target_(DataRate::Zero()),
min_bitrate_configured_(
- DataRate::bps(congestion_controller::GetMinBitrateBps())),
+ DataRate::BitsPerSec(congestion_controller::GetMinBitrateBps())),
max_bitrate_configured_(kDefaultMaxBitrate),
last_low_bitrate_log_(Timestamp::MinusInfinity()),
has_decreased_since_last_fraction_loss_(false),
@@ -223,7 +223,7 @@
RTC_LOG(LS_INFO) << "Enabled BweLossExperiment with parameters "
<< low_loss_threshold_ << ", " << high_loss_threshold_
<< ", " << bitrate_threshold_kbps;
- bitrate_threshold_ = DataRate::kbps(bitrate_threshold_kbps);
+ bitrate_threshold_ = DataRate::KilobitsPerSec(bitrate_threshold_kbps);
}
}
}
@@ -235,7 +235,7 @@
expected_packets_since_last_loss_update_ = 0;
current_target_ = DataRate::Zero();
min_bitrate_configured_ =
- DataRate::bps(congestion_controller::GetMinBitrateBps());
+ DataRate::BitsPerSec(congestion_controller::GetMinBitrateBps());
max_bitrate_configured_ = kDefaultMaxBitrate;
last_low_bitrate_log_ = Timestamp::MinusInfinity();
has_decreased_since_last_fraction_loss_ = false;
@@ -373,7 +373,8 @@
void SendSideBandwidthEstimation::UpdateUmaStatsPacketsLost(Timestamp at_time,
int packets_lost) {
- DataRate bitrate_kbps = DataRate::kbps((current_target_.bps() + 500) / 1000);
+ DataRate bitrate_kbps =
+ DataRate::KilobitsPerSec((current_target_.bps() + 500) / 1000);
for (size_t i = 0; i < kNumUmaRampupMetrics; ++i) {
if (!rampup_uma_stats_updated_[i] &&
bitrate_kbps.kbps() >= kUmaRampupMetrics[i].bitrate_kbps) {
@@ -490,13 +491,13 @@
// If instead one would do: current_bitrate_ *= 1.08^(delta time),
// it would take over one second since the lower packet loss to achieve
// 108kbps.
- DataRate new_bitrate =
- DataRate::bps(min_bitrate_history_.front().second.bps() * 1.08 + 0.5);
+ DataRate new_bitrate = DataRate::BitsPerSec(
+ min_bitrate_history_.front().second.bps() * 1.08 + 0.5);
// Add 1 kbps extra, just to make sure that we do not get stuck
// (gives a little extra increase at low rates, negligible at higher
// rates).
- new_bitrate += DataRate::bps(1000);
+ new_bitrate += DataRate::BitsPerSec(1000);
UpdateTargetBitrate(new_bitrate, at_time);
return;
} else if (current_target_ > bitrate_threshold_) {
@@ -513,10 +514,10 @@
// Reduce rate:
// newRate = rate * (1 - 0.5*lossRate);
// where packetLoss = 256*lossRate;
- DataRate new_bitrate =
- DataRate::bps((current_target_.bps() *
- static_cast<double>(512 - last_fraction_loss_)) /
- 512.0);
+ DataRate new_bitrate = DataRate::BitsPerSec(
+ (current_target_.bps() *
+ static_cast<double>(512 - last_fraction_loss_)) /
+ 512.0);
has_decreased_since_last_fraction_loss_ = true;
UpdateTargetBitrate(new_bitrate, at_time);
return;
@@ -572,7 +573,7 @@
at_time - last_loss_packet_report_;
if (time_since_loss_packet_report < 1.2 * kMaxRtcpFeedbackInterval) {
new_bitrate = min_bitrate_history_.front().second * 1.08;
- new_bitrate += DataRate::bps(1000);
+ new_bitrate += DataRate::BitsPerSec(1000);
}
return new_bitrate;
}
diff --git a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc
index 3b75ed1..06e3925 100644
--- a/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc
+++ b/modules/congestion_controller/goog_cc/send_side_bandwidth_estimation_unittest.cc
@@ -38,8 +38,9 @@
::testing::NiceMock<MockRtcEventLog> event_log;
SendSideBandwidthEstimation bwe(&event_log);
int64_t now_ms = 0;
- bwe.SetMinMaxBitrate(DataRate::bps(100000), DataRate::bps(1500000));
- bwe.SetSendBitrate(DataRate::bps(200000), Timestamp::Millis(now_ms));
+ bwe.SetMinMaxBitrate(DataRate::BitsPerSec(100000),
+ DataRate::BitsPerSec(1500000));
+ bwe.SetSendBitrate(DataRate::BitsPerSec(200000), Timestamp::Millis(now_ms));
const int kRembBps = 1000000;
const int kSecondRembBps = kRembBps + 500000;
@@ -51,10 +52,10 @@
// Initial REMB applies immediately.
if (use_delay_based) {
bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
- DataRate::bps(kRembBps));
+ DataRate::BitsPerSec(kRembBps));
} else {
bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms),
- DataRate::bps(kRembBps));
+ DataRate::BitsPerSec(kRembBps));
}
bwe.UpdateEstimate(Timestamp::Millis(now_ms));
EXPECT_EQ(kRembBps, bwe.target_rate().bps());
@@ -63,10 +64,10 @@
now_ms += 2001;
if (use_delay_based) {
bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
- DataRate::bps(kSecondRembBps));
+ DataRate::BitsPerSec(kSecondRembBps));
} else {
bwe.UpdateReceiverEstimate(Timestamp::Millis(now_ms),
- DataRate::bps(kSecondRembBps));
+ DataRate::BitsPerSec(kSecondRembBps));
}
bwe.UpdateEstimate(Timestamp::Millis(now_ms));
EXPECT_EQ(kRembBps, bwe.target_rate().bps());
@@ -91,8 +92,9 @@
static const int kMinBitrateBps = 100000;
static const int kInitialBitrateBps = 1000000;
int64_t now_ms = 1000;
- bwe.SetMinMaxBitrate(DataRate::bps(kMinBitrateBps), DataRate::bps(1500000));
- bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps),
+ bwe.SetMinMaxBitrate(DataRate::BitsPerSec(kMinBitrateBps),
+ DataRate::BitsPerSec(1500000));
+ bwe.SetSendBitrate(DataRate::BitsPerSec(kInitialBitrateBps),
Timestamp::Millis(now_ms));
static const uint8_t kFractionLoss = 128;
@@ -145,18 +147,18 @@
int64_t now_ms = 0;
- bwe.SetMinMaxBitrate(DataRate::bps(kMinBitrateBps),
- DataRate::bps(kMaxBitrateBps));
- bwe.SetSendBitrate(DataRate::bps(kInitialBitrateBps),
+ bwe.SetMinMaxBitrate(DataRate::BitsPerSec(kMinBitrateBps),
+ DataRate::BitsPerSec(kMaxBitrateBps));
+ bwe.SetSendBitrate(DataRate::BitsPerSec(kInitialBitrateBps),
Timestamp::Millis(now_ms));
bwe.UpdateDelayBasedEstimate(Timestamp::Millis(now_ms),
- DataRate::bps(kDelayBasedBitrateBps));
+ DataRate::BitsPerSec(kDelayBasedBitrateBps));
bwe.UpdateEstimate(Timestamp::Millis(now_ms));
EXPECT_GE(bwe.target_rate().bps(), kInitialBitrateBps);
EXPECT_LE(bwe.target_rate().bps(), kDelayBasedBitrateBps);
- bwe.SetSendBitrate(DataRate::bps(kForcedHighBitrate),
+ bwe.SetSendBitrate(DataRate::BitsPerSec(kForcedHighBitrate),
Timestamp::Millis(now_ms));
EXPECT_EQ(bwe.target_rate().bps(), kForcedHighBitrate);
}
diff --git a/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc b/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc
index a0b3f37..20db4ab 100644
--- a/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc
+++ b/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc
@@ -70,7 +70,7 @@
std::deque<FieldLogger*> GoogCcStatePrinter::CreateLoggers() {
auto stable_estimate = [this] {
- return DataRate::kbps(
+ return DataRate::KilobitsPerSec(
controller_->delay_based_bwe_->rate_control_.link_capacity_
.estimate_kbps_.value_or(-INFINITY));
};
diff --git a/modules/congestion_controller/pcc/bitrate_controller.cc b/modules/congestion_controller/pcc/bitrate_controller.cc
index 44f306d..16b8e69 100644
--- a/modules/congestion_controller/pcc/bitrate_controller.cc
+++ b/modules/congestion_controller/pcc/bitrate_controller.cc
@@ -131,7 +131,7 @@
double rate_change_bps = gradient * ComputeStepSize(gradient); // delta_r
rate_change_bps =
ApplyDynamicBoundary(rate_change_bps, bandwith_estimate.bps());
- return DataRate::bps(
+ return DataRate::BitsPerSec(
std::max(0.0, bandwith_estimate.bps() + rate_change_bps));
}
diff --git a/modules/congestion_controller/pcc/bitrate_controller_unittest.cc b/modules/congestion_controller/pcc/bitrate_controller_unittest.cc
index 0d3c441..6693b7a 100644
--- a/modules/congestion_controller/pcc/bitrate_controller_unittest.cc
+++ b/modules/congestion_controller/pcc/bitrate_controller_unittest.cc
@@ -32,13 +32,13 @@
constexpr double kDelayGradientThreshold = 0.01;
constexpr double kDelayGradientNegativeBound = 10;
-const DataRate kTargetSendingRate = DataRate::kbps(300);
+const DataRate kTargetSendingRate = DataRate::KilobitsPerSec(300);
const double kEpsilon = 0.05;
const Timestamp kStartTime = Timestamp::Micros(0);
const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
const TimeDelta kIntervalDuration = TimeDelta::Millis(1000);
const TimeDelta kDefaultRtt = TimeDelta::Millis(1000);
-const DataSize kDefaultDataSize = DataSize::bytes(100);
+const DataSize kDefaultDataSize = DataSize::Bytes(100);
std::vector<PacketResult> CreatePacketResults(
const std::vector<Timestamp>& packets_send_times,
diff --git a/modules/congestion_controller/pcc/monitor_interval_unittest.cc b/modules/congestion_controller/pcc/monitor_interval_unittest.cc
index 92cebd1..aaff57b 100644
--- a/modules/congestion_controller/pcc/monitor_interval_unittest.cc
+++ b/modules/congestion_controller/pcc/monitor_interval_unittest.cc
@@ -18,12 +18,12 @@
namespace pcc {
namespace test {
namespace {
-const DataRate kTargetSendingRate = DataRate::kbps(300);
+const DataRate kTargetSendingRate = DataRate::KilobitsPerSec(300);
const Timestamp kStartTime = Timestamp::Micros(0);
const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
const TimeDelta kIntervalDuration = TimeDelta::Millis(100);
const TimeDelta kDefaultDelay = TimeDelta::Millis(100);
-const DataSize kDefaultPacketSize = DataSize::bytes(100);
+const DataSize kDefaultPacketSize = DataSize::Bytes(100);
constexpr double kDelayGradientThreshold = 0.01;
std::vector<PacketResult> CreatePacketResults(
diff --git a/modules/congestion_controller/pcc/pcc_network_controller.cc b/modules/congestion_controller/pcc/pcc_network_controller.cc
index b38dce0..9801b09 100644
--- a/modules/congestion_controller/pcc/pcc_network_controller.cc
+++ b/modules/congestion_controller/pcc/pcc_network_controller.cc
@@ -57,7 +57,7 @@
last_sent_packet_time_(Timestamp::PlusInfinity()),
smoothed_packets_sending_interval_(TimeDelta::Zero()),
mode_(Mode::kStartup),
- default_bandwidth_(DataRate::kbps(kInitialBandwidthKbps)),
+ default_bandwidth_(DataRate::KilobitsPerSec(kInitialBandwidthKbps)),
bandwidth_estimate_(default_bandwidth_),
rtt_tracker_(TimeDelta::Millis(kInitialRttMs), kAlphaForRtt),
monitor_interval_timeout_(TimeDelta::Millis(kInitialRttMs) *
@@ -216,9 +216,9 @@
bandwidth_estimate_ * (1 - sign * sampling_step_)};
} else {
monitor_intervals_bitrates_ = {
- DataRate::bps(std::max<double>(
+ DataRate::BitsPerSec(std::max<double>(
bandwidth_estimate_.bps() + sign * kMinRateChangeBps, 0)),
- DataRate::bps(std::max<double>(
+ DataRate::BitsPerSec(std::max<double>(
bandwidth_estimate_.bps() - sign * kMinRateChangeBps, 0))};
}
monitor_intervals_.emplace_back(monitor_intervals_bitrates_[0],
diff --git a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc b/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc
index ad01cad..c98680c 100644
--- a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc
+++ b/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc
@@ -28,7 +28,7 @@
namespace test {
namespace {
-const DataRate kInitialBitrate = DataRate::kbps(60);
+const DataRate kInitialBitrate = DataRate::KilobitsPerSec(60);
const Timestamp kDefaultStartTime = Timestamp::Millis(10000000);
constexpr double kDataRateMargin = 0.20;
@@ -47,9 +47,12 @@
int max_data_rate_kbps = 5 * kInitialBitrate.kbps()) {
NetworkControllerConfig config;
config.constraints.at_time = kDefaultStartTime;
- config.constraints.min_data_rate = DataRate::kbps(min_data_rate_kbps);
- config.constraints.max_data_rate = DataRate::kbps(max_data_rate_kbps);
- config.constraints.starting_rate = DataRate::kbps(starting_bandwidth_kbps);
+ config.constraints.min_data_rate =
+ DataRate::KilobitsPerSec(min_data_rate_kbps);
+ config.constraints.max_data_rate =
+ DataRate::KilobitsPerSec(max_data_rate_kbps);
+ config.constraints.starting_rate =
+ DataRate::KilobitsPerSec(starting_bandwidth_kbps);
return config;
}
@@ -77,11 +80,11 @@
Scenario s("pcc_unit/updates_rate", false);
CallClientConfig config;
config.transport.cc_factory = &factory;
- config.transport.rates.min_rate = DataRate::kbps(10);
- config.transport.rates.max_rate = DataRate::kbps(1500);
- config.transport.rates.start_rate = DataRate::kbps(300);
+ config.transport.rates.min_rate = DataRate::KilobitsPerSec(10);
+ config.transport.rates.max_rate = DataRate::KilobitsPerSec(1500);
+ config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
auto send_net = s.CreateMutableSimulationNode([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(500);
+ c->bandwidth = DataRate::KilobitsPerSec(500);
c->delay = TimeDelta::Millis(100);
});
auto ret_net = s.CreateMutableSimulationNode(
@@ -97,13 +100,13 @@
s.RunFor(TimeDelta::Seconds(30));
EXPECT_NEAR(client->target_rate().kbps(), 450, 100);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(800);
+ c->bandwidth = DataRate::KilobitsPerSec(800);
c->delay = TimeDelta::Millis(100);
});
s.RunFor(TimeDelta::Seconds(20));
EXPECT_NEAR(client->target_rate().kbps(), 750, 150);
send_net->UpdateConfig([](NetworkSimulationConfig* c) {
- c->bandwidth = DataRate::kbps(200);
+ c->bandwidth = DataRate::KilobitsPerSec(200);
c->delay = TimeDelta::Millis(200);
});
ret_net->UpdateConfig(
diff --git a/modules/congestion_controller/pcc/utility_function_unittest.cc b/modules/congestion_controller/pcc/utility_function_unittest.cc
index 6f2bc81..19b2d15 100644
--- a/modules/congestion_controller/pcc/utility_function_unittest.cc
+++ b/modules/congestion_controller/pcc/utility_function_unittest.cc
@@ -35,9 +35,9 @@
const Timestamp kStartTime = Timestamp::Micros(0);
const TimeDelta kPacketsDelta = TimeDelta::Millis(1);
const TimeDelta kIntervalDuration = TimeDelta::Millis(100);
-const DataRate kSendingBitrate = DataRate::bps(1000);
+const DataRate kSendingBitrate = DataRate::BitsPerSec(1000);
-const DataSize kDefaultDataSize = DataSize::bytes(100);
+const DataSize kDefaultDataSize = DataSize::Bytes(100);
const TimeDelta kDefaultDelay = TimeDelta::Millis(100);
std::vector<PacketResult> CreatePacketResults(
diff --git a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc
index 5c344ad..95143f7 100644
--- a/modules/congestion_controller/receive_side_congestion_controller_unittest.cc
+++ b/modules/congestion_controller/receive_side_congestion_controller_unittest.cc
@@ -76,10 +76,10 @@
TEST(ReceiveSideCongestionControllerTest, ConvergesToCapacity) {
Scenario s("recieve_cc_unit/converge");
NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(1000);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(1000);
net_conf.delay = TimeDelta::Millis(50);
auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
- c->transport.rates.start_rate = DataRate::kbps(300);
+ c->transport.rates.start_rate = DataRate::KilobitsPerSec(300);
});
auto* route = s.CreateRoutes(client, {s.CreateSimulationNode(net_conf)},
@@ -95,10 +95,10 @@
TEST(ReceiveSideCongestionControllerTest, IsFairToTCP) {
Scenario s("recieve_cc_unit/tcp_fairness");
NetworkSimulationConfig net_conf;
- net_conf.bandwidth = DataRate::kbps(1000);
+ net_conf.bandwidth = DataRate::KilobitsPerSec(1000);
net_conf.delay = TimeDelta::Millis(50);
auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
- c->transport.rates.start_rate = DataRate::kbps(1000);
+ c->transport.rates.start_rate = DataRate::KilobitsPerSec(1000);
});
auto send_net = {s.CreateSimulationNode(net_conf)};
auto ret_net = {s.CreateSimulationNode(net_conf)};
diff --git a/modules/congestion_controller/rtp/transport_feedback_adapter.cc b/modules/congestion_controller/rtp/transport_feedback_adapter.cc
index 301c157..b98de9c 100644
--- a/modules/congestion_controller/rtp/transport_feedback_adapter.cc
+++ b/modules/congestion_controller/rtp/transport_feedback_adapter.cc
@@ -74,7 +74,7 @@
packet.creation_time = creation_time;
packet.sent.sequence_number =
seq_num_unwrapper_.Unwrap(packet_info.transport_sequence_number);
- packet.sent.size = DataSize::bytes(packet_info.length + overhead_bytes);
+ packet.sent.size = DataSize::Bytes(packet_info.length + overhead_bytes);
packet.local_net_id = local_net_id_;
packet.remote_net_id = remote_net_id_;
packet.sent.pacing_info = packet_info.pacing_info;
@@ -122,7 +122,7 @@
RTC_LOG(LS_WARNING) << "ignoring untracked data for out of order packet.";
}
pending_untracked_size_ +=
- DataSize::bytes(sent_packet.info.packet_size_bytes);
+ DataSize::Bytes(sent_packet.info.packet_size_bytes);
last_untracked_send_time_ = std::max(last_untracked_send_time_, send_time);
}
return absl::nullopt;
diff --git a/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc b/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
index d14a334..31692d5 100644
--- a/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
+++ b/modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
@@ -72,7 +72,7 @@
res.receive_time = Timestamp::Millis(receive_time_ms);
res.sent_packet.send_time = Timestamp::Millis(send_time_ms);
res.sent_packet.sequence_number = sequence_number;
- res.sent_packet.size = DataSize::bytes(payload_size);
+ res.sent_packet.size = DataSize::Bytes(payload_size);
res.sent_packet.pacing_info = pacing_info;
return res;
}
@@ -309,7 +309,7 @@
packet_feedback.sent_packet.sequence_number = 1;
packet_feedback.sent_packet.send_time = Timestamp::Millis(100);
packet_feedback.receive_time = Timestamp::Millis(200);
- packet_feedback.sent_packet.size = DataSize::bytes(1500);
+ packet_feedback.sent_packet.size = DataSize::Bytes(1500);
sent_packets.push_back(packet_feedback);
// TODO(srte): This rounding maintains previous behavior, but should ot be
diff --git a/modules/pacing/bitrate_prober.cc b/modules/pacing/bitrate_prober.cc
index 44fd810..e4ac7dd 100644
--- a/modules/pacing/bitrate_prober.cc
+++ b/modules/pacing/bitrate_prober.cc
@@ -194,8 +194,9 @@
// Compute the time delta from the cluster start to ensure probe bitrate stays
// close to the target bitrate. Result is in milliseconds.
- DataSize sent_bytes = DataSize::bytes(cluster.sent_bytes);
- DataRate send_bitrate = DataRate::bps(cluster.pace_info.send_bitrate_bps);
+ DataSize sent_bytes = DataSize::Bytes(cluster.sent_bytes);
+ DataRate send_bitrate =
+ DataRate::BitsPerSec(cluster.pace_info.send_bitrate_bps);
TimeDelta delta = sent_bytes / send_bitrate;
return cluster.started_at + delta;
}
diff --git a/modules/pacing/bitrate_prober_unittest.cc b/modules/pacing/bitrate_prober_unittest.cc
index 041cf93..2d10c04 100644
--- a/modules/pacing/bitrate_prober_unittest.cc
+++ b/modules/pacing/bitrate_prober_unittest.cc
@@ -25,8 +25,8 @@
const Timestamp start_time = now;
EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
- const DataRate kTestBitrate1 = DataRate::kbps(900);
- const DataRate kTestBitrate2 = DataRate::kbps(1800);
+ const DataRate kTestBitrate1 = DataRate::KilobitsPerSec(900);
+ const DataRate kTestBitrate2 = DataRate::KilobitsPerSec(1800);
const int kClusterSize = 5;
const int kProbeSize = 1000;
const TimeDelta kMinProbeDuration = TimeDelta::Millis(15);
@@ -52,7 +52,7 @@
EXPECT_GE(now - start_time, kMinProbeDuration);
// Verify that the actual bitrate is withing 10% of the target.
DataRate bitrate =
- DataSize::bytes(kProbeSize * (kClusterSize - 1)) / (now - start_time);
+ DataSize::Bytes(kProbeSize * (kClusterSize - 1)) / (now - start_time);
EXPECT_GT(bitrate, kTestBitrate1 * 0.9);
EXPECT_LT(bitrate, kTestBitrate1 * 1.1);
@@ -69,7 +69,7 @@
// Verify that the actual bitrate is withing 10% of the target.
TimeDelta duration = now - probe2_started;
EXPECT_GE(duration, kMinProbeDuration);
- bitrate = DataSize::bytes(kProbeSize * (kClusterSize - 1)) / duration;
+ bitrate = DataSize::Bytes(kProbeSize * (kClusterSize - 1)) / duration;
EXPECT_GT(bitrate, kTestBitrate2 * 0.9);
EXPECT_LT(bitrate, kTestBitrate2 * 1.1);
@@ -84,7 +84,7 @@
Timestamp now = Timestamp::Zero();
EXPECT_EQ(prober.NextProbeTime(now), Timestamp::PlusInfinity());
- prober.CreateProbeCluster(DataRate::kbps(900), now, 0);
+ prober.CreateProbeCluster(DataRate::KilobitsPerSec(900), now, 0);
EXPECT_FALSE(prober.IsProbing());
prober.OnIncomingPacket(1000);
@@ -115,7 +115,7 @@
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kHighBitrate = DataRate::kbps(10000); // 10 Mbps
+ const DataRate kHighBitrate = DataRate::KilobitsPerSec(10000); // 10 Mbps
prober.CreateProbeCluster(kHighBitrate, Timestamp::Millis(0),
/*cluster_id=*/0);
@@ -129,7 +129,7 @@
BitrateProber prober(config);
// Even when probing at a low bitrate we expect a minimum number
// of packets to be sent.
- const DataRate kBitrate = DataRate::kbps(100);
+ const DataRate kBitrate = DataRate::KilobitsPerSec(100);
const int kPacketSizeBytes = 1000;
Timestamp now = Timestamp::Millis(0);
@@ -146,7 +146,7 @@
TEST(BitrateProberTest, ScaleBytesUsedForProbing) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(10000); // 10 Mbps.
+ const DataRate kBitrate = DataRate::KilobitsPerSec(10000); // 10 Mbps.
const int kPacketSizeBytes = 1000;
const int kExpectedBytesSent = (kBitrate * TimeDelta::Millis(15)).bytes();
@@ -166,7 +166,7 @@
TEST(BitrateProberTest, HighBitrateProbing) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(1000000); // 1 Gbps.
+ const DataRate kBitrate = DataRate::KilobitsPerSec(1000000); // 1 Gbps.
const int kPacketSizeBytes = 1000;
const int kExpectedBytesSent = (kBitrate * TimeDelta::Millis(15)).bytes();
@@ -186,7 +186,7 @@
TEST(BitrateProberTest, ProbeClusterTimeout) {
const FieldTrialBasedConfig config;
BitrateProber prober(config);
- const DataRate kBitrate = DataRate::kbps(300);
+ const DataRate kBitrate = DataRate::KilobitsPerSec(300);
const int kSmallPacketSize = 20;
// Expecting two probe clusters of 5 packets each.
const int kExpectedBytesSent = 20 * 2 * 5;
diff --git a/modules/pacing/paced_sender_unittest.cc b/modules/pacing/paced_sender_unittest.cc
index b05792a..26d2eac 100644
--- a/modules/pacing/paced_sender_unittest.cc
+++ b/modules/pacing/paced_sender_unittest.cc
@@ -120,8 +120,9 @@
TEST_P(PacedSenderTest, PacesPackets) {
// Insert a number of packets, covering one second.
static constexpr size_t kPacketsToSend = 42;
- pacer_->SetPacingRates(DataRate::bps(kDefaultPacketSize * 8 * kPacketsToSend),
- DataRate::Zero());
+ pacer_->SetPacingRates(
+ DataRate::BitsPerSec(kDefaultPacketSize * 8 * kPacketsToSend),
+ DataRate::Zero());
std::vector<std::unique_ptr<RtpPacketToSend>> packets;
for (size_t i = 0; i < kPacketsToSend; ++i) {
packets.emplace_back(BuildRtpPacket(RtpPacketMediaType::kVideo));
diff --git a/modules/pacing/pacing_controller.cc b/modules/pacing/pacing_controller.cc
index bc46da5..8d41963 100644
--- a/modules/pacing/pacing_controller.cc
+++ b/modules/pacing/pacing_controller.cc
@@ -32,7 +32,7 @@
// The maximum debt level, in terms of time, capped when sending packets.
constexpr TimeDelta kMaxDebtInTime = TimeDelta::Millis(500);
constexpr TimeDelta kMaxElapsedTime = TimeDelta::Seconds(2);
-constexpr DataSize kDefaultPaddingTarget = DataSize::Bytes<50>();
+constexpr DataSize kDefaultPaddingTarget = DataSize::Bytes(50);
// Upper cap on process interval, in case process has not been called in a long
// time.
@@ -415,10 +415,10 @@
} else {
DataSize keepalive_data_sent = DataSize::Zero();
std::vector<std::unique_ptr<RtpPacketToSend>> keepalive_packets =
- packet_sender_->GeneratePadding(DataSize::bytes(1));
+ packet_sender_->GeneratePadding(DataSize::Bytes(1));
for (auto& packet : keepalive_packets) {
keepalive_data_sent +=
- DataSize::bytes(packet->payload_size() + packet->padding_size());
+ DataSize::Bytes(packet->payload_size() + packet->padding_size());
packet_sender_->SendRtpPacket(std::move(packet), PacedPacketInfo());
}
OnPaddingSent(keepalive_data_sent);
@@ -468,7 +468,7 @@
if (is_probing) {
pacing_info = prober_.CurrentCluster();
first_packet_in_probe = pacing_info.probe_cluster_bytes_sent == 0;
- recommended_probe_size = DataSize::bytes(prober_.RecommendedMinProbeSize());
+ recommended_probe_size = DataSize::Bytes(prober_.RecommendedMinProbeSize());
}
DataSize data_sent = DataSize::Zero();
@@ -479,7 +479,7 @@
if (small_first_probe_packet_ && first_packet_in_probe) {
// If first packet in probe, insert a small padding packet so we have a
// more reliable start window for the rate estimation.
- auto padding = packet_sender_->GeneratePadding(DataSize::bytes(1));
+ auto padding = packet_sender_->GeneratePadding(DataSize::Bytes(1));
// If no RTP modules sending media are registered, we may not get a
// padding packet back.
if (!padding.empty()) {
@@ -531,11 +531,11 @@
RTC_DCHECK(rtp_packet);
RTC_DCHECK(rtp_packet->packet_type().has_value());
const RtpPacketMediaType packet_type = *rtp_packet->packet_type();
- DataSize packet_size = DataSize::bytes(rtp_packet->payload_size() +
+ DataSize packet_size = DataSize::Bytes(rtp_packet->payload_size() +
rtp_packet->padding_size());
if (include_overhead_) {
- packet_size += DataSize::bytes(rtp_packet->headers_size()) +
+ packet_size += DataSize::Bytes(rtp_packet->headers_size()) +
transport_overhead_per_packet_;
}
packet_sender_->SendRtpPacket(std::move(rtp_packet), pacing_info);
@@ -594,7 +594,7 @@
}
if (mode_ == ProcessMode::kPeriodic) {
- return DataSize::bytes(padding_budget_.bytes_remaining());
+ return DataSize::Bytes(padding_budget_.bytes_remaining());
} else if (padding_rate_ > DataRate::Zero() &&
padding_debt_ == DataSize::Zero()) {
return kDefaultPaddingTarget;
diff --git a/modules/pacing/pacing_controller_unittest.cc b/modules/pacing/pacing_controller_unittest.cc
index 9375dda..64ae00e 100644
--- a/modules/pacing/pacing_controller_unittest.cc
+++ b/modules/pacing/pacing_controller_unittest.cc
@@ -33,13 +33,13 @@
namespace webrtc {
namespace test {
namespace {
-constexpr DataRate kFirstClusterRate = DataRate::KilobitsPerSec<900>();
-constexpr DataRate kSecondClusterRate = DataRate::KilobitsPerSec<1800>();
+constexpr DataRate kFirstClusterRate = DataRate::KilobitsPerSec(900);
+constexpr DataRate kSecondClusterRate = DataRate::KilobitsPerSec(1800);
// The error stems from truncating the time interval of probe packets to integer
// values. This results in probing slightly higher than the target bitrate.
// For 1.8 Mbps, this comes to be about 120 kbps with 1200 probe packets.
-constexpr DataRate kProbingErrorMargin = DataRate::KilobitsPerSec<150>();
+constexpr DataRate kProbingErrorMargin = DataRate::KilobitsPerSec(150);
const float kPaceMultiplier = 2.5f;
@@ -48,7 +48,7 @@
constexpr uint32_t kVideoRtxSsrc = 34567;
constexpr uint32_t kFlexFecSsrc = 45678;
-constexpr DataRate kTargetRate = DataRate::KilobitsPerSec<800>();
+constexpr DataRate kTargetRate = DataRate::KilobitsPerSec(800);
std::unique_ptr<RtpPacketToSend> BuildPacket(RtpPacketMediaType type,
uint32_t ssrc,
@@ -158,7 +158,7 @@
DataSize target_size) override {
// From RTPSender:
// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
- const DataSize kMaxPadding = DataSize::bytes(224);
+ const DataSize kMaxPadding = DataSize::Bytes(224);
std::vector<std::unique_ptr<RtpPacketToSend>> packets;
while (target_size > DataSize::Zero()) {
@@ -370,8 +370,8 @@
ScopedFieldTrials trial("WebRTC-Pacer-BlockAudio/Enabled/");
EXPECT_CALL(callback_, SendPadding).Times(0);
PacingController pacer(&clock_, &callback_, nullptr, nullptr, GetParam());
- pacer.SetPacingRates(DataRate::kbps(10000), DataRate::Zero());
- pacer.SetCongestionWindow(DataSize::bytes(video.packet_size - 100));
+ pacer.SetPacingRates(DataRate::KilobitsPerSec(10000), DataRate::Zero());
+ pacer.SetCongestionWindow(DataSize::Bytes(video.packet_size - 100));
pacer.UpdateOutstandingData(DataSize::Zero());
// Video packet fills congestion window.
InsertPacket(&pacer, &video);
@@ -397,8 +397,8 @@
DefaultCongestionWindowDoesNotAffectAudio) {
EXPECT_CALL(callback_, SendPadding).Times(0);
PacingController pacer(&clock_, &callback_, nullptr, nullptr, GetParam());
- pacer.SetPacingRates(DataRate::bps(10000000), DataRate::Zero());
- pacer.SetCongestionWindow(DataSize::bytes(800));
+ pacer.SetPacingRates(DataRate::BitsPerSec(10000000), DataRate::Zero());
+ pacer.SetCongestionWindow(DataSize::Bytes(800));
pacer.UpdateOutstandingData(DataSize::Zero());
// Video packet fills congestion window.
InsertPacket(&pacer, &video);
@@ -413,8 +413,8 @@
TEST_P(PacingControllerFieldTrialTest, BudgetAffectsAudioInTrial) {
ScopedFieldTrials trial("WebRTC-Pacer-BlockAudio/Enabled/");
PacingController pacer(&clock_, &callback_, nullptr, nullptr, GetParam());
- DataRate pacing_rate =
- DataRate::bps(video.packet_size / 3 * 8 * kProcessIntervalsPerSecond);
+ DataRate pacing_rate = DataRate::BitsPerSec(video.packet_size / 3 * 8 *
+ kProcessIntervalsPerSecond);
pacer.SetPacingRates(pacing_rate, DataRate::Zero());
// Video fills budget for following process periods.
InsertPacket(&pacer, &video);
@@ -432,7 +432,7 @@
ProcessNext(&pacer);
}
const TimeDelta expected_wait_time =
- DataSize::bytes(video.packet_size) / pacing_rate;
+ DataSize::Bytes(video.packet_size) / pacing_rate;
// Verify delay is near expectation, within timing margin.
EXPECT_LT(((wait_end_time - wait_start_time) - expected_wait_time).Abs(),
GetParam() == PacingController::ProcessMode::kPeriodic
@@ -443,9 +443,9 @@
TEST_P(PacingControllerFieldTrialTest, DefaultBudgetDoesNotAffectAudio) {
EXPECT_CALL(callback_, SendPadding).Times(0);
PacingController pacer(&clock_, &callback_, nullptr, nullptr, GetParam());
- pacer.SetPacingRates(
- DataRate::bps(video.packet_size / 3 * 8 * kProcessIntervalsPerSecond),
- DataRate::Zero());
+ pacer.SetPacingRates(DataRate::BitsPerSec(video.packet_size / 3 * 8 *
+ kProcessIntervalsPerSecond),
+ DataRate::Zero());
// Video fills budget for following process periods.
InsertPacket(&pacer, &video);
EXPECT_CALL(callback_, SendPacket).Times(1);
@@ -539,7 +539,7 @@
const uint32_t kSsrc = 12345;
uint16_t sequence_number = 1234;
- const DataSize kPackeSize = DataSize::bytes(250);
+ const DataSize kPackeSize = DataSize::Bytes(250);
const TimeDelta kSendInterval = TimeDelta::Millis(5);
// Due to the multiplicative factor we can send 5 packets during a 5ms send
@@ -609,7 +609,7 @@
EXPECT_CALL(callback_, SendPacket(ssrc, _, _, false, false))
.Times(pacer_->QueueSizePackets());
const TimeDelta expected_pace_time =
- DataSize::bytes(pacer_->QueueSizePackets() * kPacketSize) /
+ DataSize::Bytes(pacer_->QueueSizePackets() * kPacketSize) /
(kPaceMultiplier * kTargetRate);
Timestamp start_time = clock_.CurrentTime();
while (pacer_->QueueSizePackets() > 0) {
@@ -718,7 +718,7 @@
clock_.TimeInMilliseconds(), kPacketSize);
}
const TimeDelta expected_pace_time =
- DataSize::bytes(pacer_->QueueSizePackets() * kPacketSize) /
+ DataSize::Bytes(pacer_->QueueSizePackets() * kPacketSize) /
(kPaceMultiplier * kTargetRate);
EXPECT_CALL(callback_, SendPadding).Times(0);
// Only the media packets should be sent.
@@ -754,7 +754,7 @@
// Don't count bytes of last packet, instead just
// use this as the time the last packet finished
// sending.
- padding_sent += DataSize::bytes(target_size);
+ padding_sent += DataSize::Bytes(target_size);
}
if (first_send_time.IsInfinite()) {
first_send_time = clock_.CurrentTime();
@@ -869,7 +869,7 @@
EXPECT_NEAR(
kTargetRate.bps(),
- (DataSize::bytes(callback.total_bytes_sent()) / kAveragingWindowLength)
+ (DataSize::Bytes(callback.total_bytes_sent()) / kAveragingWindowLength)
.bps(),
(kTargetRate * 0.01 /* 1% error marging */).bps());
}
@@ -1021,7 +1021,7 @@
// Measure pacing time. Expect only low-prio packets to affect this.
TimeDelta pacing_time = clock_.CurrentTime() - start_time;
TimeDelta expected_pacing_time =
- DataSize::bytes(kPacketsToSendPerInterval * kPacketSize) /
+ DataSize::Bytes(kPacketsToSendPerInterval * kPacketSize) /
(kTargetRate * kPaceMultiplier);
EXPECT_NEAR(pacing_time.us<double>(), expected_pacing_time.us<double>(),
PeriodicProcess() ? 5000.0
@@ -1035,7 +1035,7 @@
int kCongestionWindow = kPacketSize * 10;
pacer_->UpdateOutstandingData(DataSize::Zero());
- pacer_->SetCongestionWindow(DataSize::bytes(kCongestionWindow));
+ pacer_->SetCongestionWindow(DataSize::Bytes(kCongestionWindow));
int sent_data = 0;
while (sent_data < kCongestionWindow) {
sent_data += kPacketSize;
@@ -1073,9 +1073,10 @@
EXPECT_CALL(callback_, SendPadding).Times(0);
// The pacing rate is low enough that the budget should not allow two packets
// to be sent in a row.
- pacer_->SetPacingRates(DataRate::bps(400 * 8 * 1000 / 5), DataRate::Zero());
+ pacer_->SetPacingRates(DataRate::BitsPerSec(400 * 8 * 1000 / 5),
+ DataRate::Zero());
// The congestion window is small enough to only let one packet through.
- pacer_->SetCongestionWindow(DataSize::bytes(800));
+ pacer_->SetCongestionWindow(DataSize::Bytes(800));
pacer_->UpdateOutstandingData(DataSize::Zero());
// Not yet budget limited or congested, packet is sent.
Send(RtpPacketMediaType::kVideo, ssrc, seq_num++, now_ms(), size);
@@ -1114,7 +1115,7 @@
int64_t kCongestionTimeMs = 1000;
pacer_->UpdateOutstandingData(DataSize::Zero());
- pacer_->SetCongestionWindow(DataSize::bytes(kCongestionWindow));
+ pacer_->SetCongestionWindow(DataSize::Bytes(kCongestionWindow));
int sent_data = 0;
while (sent_data < kCongestionWindow) {
sent_data += kPacketSize;
@@ -1140,7 +1141,7 @@
int ack_count = kCongestionCount / 2;
EXPECT_CALL(callback_, SendPacket(ssrc, _, _, false, _)).Times(ack_count);
pacer_->UpdateOutstandingData(
- DataSize::bytes(kCongestionWindow - kPacketSize * ack_count));
+ DataSize::Bytes(kCongestionWindow - kPacketSize * ack_count));
for (int duration = 0; duration < kCongestionTimeMs; duration += 5) {
clock_.AdvanceTimeMilliseconds(5);
@@ -1324,7 +1325,7 @@
const int32_t kMaxBitrate = kPaceMultiplier * 30000;
EXPECT_EQ(TimeDelta::Zero(), pacer_->OldestPacketWaitTime());
- pacer_->SetPacingRates(DataRate::bps(30000 * kPaceMultiplier),
+ pacer_->SetPacingRates(DataRate::BitsPerSec(30000 * kPaceMultiplier),
DataRate::Zero());
for (size_t i = 0; i < kNumPackets; ++i) {
SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1357,7 +1358,7 @@
uint16_t sequence_number = 1234;
EXPECT_EQ(TimeDelta::Zero(), pacer_->OldestPacketWaitTime());
- pacer_->SetPacingRates(DataRate::bps(30000 * kPaceMultiplier),
+ pacer_->SetPacingRates(DataRate::BitsPerSec(30000 * kPaceMultiplier),
DataRate::Zero());
SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number,
clock_.TimeInMilliseconds(), 1200);
@@ -1381,8 +1382,9 @@
/*cluster_id=*/0);
pacer_->CreateProbeCluster(kSecondClusterRate,
/*cluster_id=*/1);
- pacer_->SetPacingRates(DataRate::bps(kInitialBitrateBps * kPaceMultiplier),
- DataRate::Zero());
+ pacer_->SetPacingRates(
+ DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier),
+ DataRate::Zero());
for (int i = 0; i < 10; ++i) {
Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1424,8 +1426,9 @@
PacingControllerProbing packet_sender;
pacer_ = std::make_unique<PacingController>(&clock_, &packet_sender, nullptr,
nullptr, GetParam());
- pacer_->SetPacingRates(DataRate::bps(kInitialBitrateBps * kPaceMultiplier),
- DataRate::Zero());
+ pacer_->SetPacingRates(
+ DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier),
+ DataRate::Zero());
for (int i = 0; i < 10; ++i) {
Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1437,7 +1440,7 @@
}
// Probe at a very high rate.
- pacer_->CreateProbeCluster(DataRate::kbps(10000), // 10 Mbps.
+ pacer_->CreateProbeCluster(DataRate::KilobitsPerSec(10000), // 10 Mbps.
/*cluster_id=*/3);
// We need one packet to start the probe.
Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1487,8 +1490,9 @@
nullptr, GetParam());
pacer_->CreateProbeCluster(kFirstClusterRate,
/*cluster_id=*/0);
- pacer_->SetPacingRates(DataRate::bps(kInitialBitrateBps * kPaceMultiplier),
- DataRate::Zero());
+ pacer_->SetPacingRates(
+ DataRate::BitsPerSec(kInitialBitrateBps * kPaceMultiplier),
+ DataRate::Zero());
for (int i = 0; i < 3; ++i) {
Send(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1520,7 +1524,7 @@
// Initially no padding rate.
pacer_->ProcessPackets();
- pacer_->SetPacingRates(DataRate::bps(60000 * kPaceMultiplier),
+ pacer_->SetPacingRates(DataRate::BitsPerSec(60000 * kPaceMultiplier),
DataRate::Zero());
SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
@@ -1530,8 +1534,8 @@
// Add 30kbit padding. When increasing budget, media budget will increase from
// negative (overuse) while padding budget will increase from 0.
clock_.AdvanceTimeMilliseconds(5);
- pacer_->SetPacingRates(DataRate::bps(60000 * kPaceMultiplier),
- DataRate::bps(30000));
+ pacer_->SetPacingRates(DataRate::BitsPerSec(60000 * kPaceMultiplier),
+ DataRate::BitsPerSec(30000));
SendAndExpectPacket(RtpPacketMediaType::kVideo, ssrc, sequence_number++,
clock_.TimeInMilliseconds(), kPacketSize);
@@ -1662,7 +1666,7 @@
pacer_->EnqueuePacket(BuildRtpPacket(RtpPacketMediaType::kAudio));
// Expect small padding packet to be requested.
- EXPECT_CALL(callback, GeneratePadding(DataSize::bytes(1)))
+ EXPECT_CALL(callback, GeneratePadding(DataSize::Bytes(1)))
.WillOnce([&](DataSize padding_size) {
std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets;
padding_packets.emplace_back(
@@ -1699,7 +1703,7 @@
}
// Set a low send rate to more easily test timing issues.
- DataRate kSendRate = DataRate::kbps(30);
+ DataRate kSendRate = DataRate::KilobitsPerSec(30);
pacer_->SetPacingRates(kSendRate, DataRate::Zero());
// Add four packets of equal size and priority.
@@ -1748,7 +1752,7 @@
}
// Trigger probing.
- pacer_->CreateProbeCluster(DataRate::kbps(10000), // 10 Mbps.
+ pacer_->CreateProbeCluster(DataRate::KilobitsPerSec(10000), // 10 Mbps.
/*cluster_id=*/3);
// Time to next send time should be small.
diff --git a/modules/pacing/round_robin_packet_queue.cc b/modules/pacing/round_robin_packet_queue.cc
index 206d6c5..d61d441 100644
--- a/modules/pacing/round_robin_packet_queue.cc
+++ b/modules/pacing/round_robin_packet_queue.cc
@@ -18,7 +18,7 @@
namespace webrtc {
namespace {
-static constexpr DataSize kMaxLeadingSize = DataSize::Bytes<1400>();
+static constexpr DataSize kMaxLeadingSize = DataSize::Bytes(1400);
}
RoundRobinPacketQueue::QueuedPacket::QueuedPacket(const QueuedPacket& rhs) =
@@ -163,10 +163,10 @@
// rate. To avoid building a too large budget we limit |bytes| to be within
// kMaxLeading bytes of the stream that has sent the most amount of bytes.
DataSize packet_size =
- DataSize::bytes(queued_packet.RtpPacket()->payload_size() +
+ DataSize::Bytes(queued_packet.RtpPacket()->payload_size() +
queued_packet.RtpPacket()->padding_size());
if (include_overhead_) {
- packet_size += DataSize::bytes(queued_packet.RtpPacket()->headers_size()) +
+ packet_size += DataSize::Bytes(queued_packet.RtpPacket()->headers_size()) +
transport_overhead_per_packet_;
}
stream->size =
@@ -253,7 +253,7 @@
// We need to update the size to reflect overhead for existing packets.
for (const auto& stream : streams_) {
for (const QueuedPacket& packet : stream.second.packet_queue) {
- size_ += DataSize::bytes(packet.RtpPacket()->headers_size()) +
+ size_ += DataSize::Bytes(packet.RtpPacket()->headers_size()) +
transport_overhead_per_packet_;
}
}
@@ -313,10 +313,10 @@
packet.SubtractPauseTime(pause_time_sum_);
size_packets_ += 1;
- size_ += DataSize::bytes(packet.RtpPacket()->payload_size() +
+ size_ += DataSize::Bytes(packet.RtpPacket()->payload_size() +
packet.RtpPacket()->padding_size());
if (include_overhead_) {
- size_ += DataSize::bytes(packet.RtpPacket()->headers_size()) +
+ size_ += DataSize::Bytes(packet.RtpPacket()->headers_size()) +
transport_overhead_per_packet_;
}
diff --git a/modules/pacing/task_queue_paced_sender_unittest.cc b/modules/pacing/task_queue_paced_sender_unittest.cc
index 61b3206..b7e6483 100644
--- a/modules/pacing/task_queue_paced_sender_unittest.cc
+++ b/modules/pacing/task_queue_paced_sender_unittest.cc
@@ -102,8 +102,9 @@
TEST_F(TaskQueuePacedSenderTest, PacesPackets) {
// Insert a number of packets, covering one second.
static constexpr size_t kPacketsToSend = 42;
- pacer_.SetPacingRates(DataRate::bps(kDefaultPacketSize * 8 * kPacketsToSend),
- DataRate::Zero());
+ pacer_.SetPacingRates(
+ DataRate::BitsPerSec(kDefaultPacketSize * 8 * kPacketsToSend),
+ DataRate::Zero());
pacer_.EnqueuePackets(
GeneratePackets(RtpPacketMediaType::kVideo, kPacketsToSend));
@@ -133,7 +134,7 @@
// Insert a number of packets to be sent 200ms apart.
const size_t kPacketsPerSecond = 5;
const DataRate kPacingRate =
- DataRate::bps(kDefaultPacketSize * 8 * kPacketsPerSecond);
+ DataRate::BitsPerSec(kDefaultPacketSize * 8 * kPacketsPerSecond);
pacer_.SetPacingRates(kPacingRate, DataRate::Zero());
// Send some initial packets to be rid of any probes.
diff --git a/modules/remote_bitrate_estimator/aimd_rate_control.cc b/modules/remote_bitrate_estimator/aimd_rate_control.cc
index 970ab08..da0acd1 100644
--- a/modules/remote_bitrate_estimator/aimd_rate_control.cc
+++ b/modules/remote_bitrate_estimator/aimd_rate_control.cc
@@ -73,7 +73,7 @@
AimdRateControl::AimdRateControl(const WebRtcKeyValueConfig* key_value_config,
bool send_side)
: min_configured_bitrate_(congestion_controller::GetMinBitrate()),
- max_configured_bitrate_(DataRate::kbps(30000)),
+ max_configured_bitrate_(DataRate::KilobitsPerSec(30000)),
current_bitrate_(max_configured_bitrate_),
latest_estimated_throughput_(current_bitrate_),
link_capacity_(),
@@ -137,7 +137,7 @@
TimeDelta AimdRateControl::GetFeedbackInterval() const {
// Estimate how often we can send RTCP if we allocate up to 5% of bandwidth
// to feedback.
- const DataSize kRtcpSize = DataSize::bytes(80);
+ const DataSize kRtcpSize = DataSize::Bytes(80);
const DataRate rtcp_bitrate = current_bitrate_ * 0.05;
const TimeDelta interval = kRtcpSize / rtcp_bitrate;
const TimeDelta kMinFeedbackInterval = TimeDelta::Millis(200);
@@ -165,7 +165,7 @@
if (!initial_backoff_interval_) {
return ValidEstimate() &&
TimeToReduceFurther(at_time,
- LatestEstimate() / 2 - DataRate::bps(1));
+ LatestEstimate() / 2 - DataRate::BitsPerSec(1));
}
// TODO(terelius): We could use the RTT (clamped to suitable limits) instead
// of a fixed bitrate_reduction_interval.
@@ -232,7 +232,7 @@
RTC_DCHECK(!current_bitrate_.IsZero());
const TimeDelta kFrameInterval = TimeDelta::Seconds(1) / 30;
DataSize frame_size = current_bitrate_ * kFrameInterval;
- const DataSize kPacketSize = DataSize::bytes(1200);
+ const DataSize kPacketSize = DataSize::Bytes(1200);
double packets_per_frame = std::ceil(frame_size / kPacketSize);
DataSize avg_packet_size = frame_size / packets_per_frame;
@@ -380,7 +380,7 @@
// We allow a bit more lag at very low rates to not too easily get stuck if
// the encoder produces uneven outputs.
const DataRate max_bitrate =
- 1.5 * estimated_throughput + DataRate::kbps(10);
+ 1.5 * estimated_throughput + DataRate::KilobitsPerSec(10);
if (new_bitrate > current_bitrate_ && new_bitrate > max_bitrate) {
new_bitrate = std::max(current_bitrate_, max_bitrate);
}
@@ -404,7 +404,7 @@
alpha = pow(alpha, std::min(time_since_last_update.seconds<double>(), 1.0));
}
DataRate multiplicative_increase =
- std::max(current_bitrate * (alpha - 1.0), DataRate::bps(1000));
+ std::max(current_bitrate * (alpha - 1.0), DataRate::BitsPerSec(1000));
return multiplicative_increase;
}
@@ -413,7 +413,7 @@
double time_period_seconds = (at_time - last_time).seconds<double>();
double data_rate_increase_bps =
GetNearMaxIncreaseRateBpsPerSecond() * time_period_seconds;
- return DataRate::bps(data_rate_increase_bps);
+ return DataRate::BitsPerSec(data_rate_increase_bps);
}
void AimdRateControl::ChangeState(const RateControlInput& input,
diff --git a/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc b/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
index 1d0987e..01bb50c 100644
--- a/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
+++ b/modules/remote_bitrate_estimator/aimd_rate_control_unittest.cc
@@ -47,7 +47,7 @@
absl::optional<DataRate> OptionalRateFromOptionalBps(
absl::optional<int> bitrate_bps) {
if (bitrate_bps) {
- return DataRate::bps(*bitrate_bps);
+ return DataRate::BitsPerSec(*bitrate_bps);
} else {
return absl::nullopt;
}
@@ -61,7 +61,7 @@
states.aimd_rate_control->Update(&input, Timestamp::Millis(now_ms));
}
void SetEstimate(const AimdRateControlStates& states, int bitrate_bps) {
- states.aimd_rate_control->SetEstimate(DataRate::bps(bitrate_bps),
+ states.aimd_rate_control->SetEstimate(DataRate::BitsPerSec(bitrate_bps),
states.simulated_clock->CurrentTime());
}
@@ -161,7 +161,7 @@
TEST(AimdRateControlTest, DefaultPeriodUntilFirstOveruse) {
// Smoothing experiment disabled
auto states = CreateAimdRateControlStates();
- states.aimd_rate_control->SetStartBitrate(DataRate::kbps(300));
+ states.aimd_rate_control->SetStartBitrate(DataRate::KilobitsPerSec(300));
EXPECT_EQ(kDefaultPeriodMsNoSmoothingExp,
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
states.simulated_clock->AdvanceTimeMilliseconds(100);
@@ -175,7 +175,7 @@
// Smoothing experiment enabled
test::ScopedFieldTrials override_field_trials(kSmoothingExpFieldTrial);
auto states = CreateAimdRateControlStates();
- states.aimd_rate_control->SetStartBitrate(DataRate::kbps(300));
+ states.aimd_rate_control->SetStartBitrate(DataRate::KilobitsPerSec(300));
EXPECT_EQ(kMinBwePeriodMsSmoothingExp,
states.aimd_rate_control->GetExpectedBandwidthPeriod().ms());
states.simulated_clock->AdvanceTimeMilliseconds(100);
diff --git a/modules/remote_bitrate_estimator/bwe_defines.cc b/modules/remote_bitrate_estimator/bwe_defines.cc
index 1a67faa..6afbe13 100644
--- a/modules/remote_bitrate_estimator/bwe_defines.cc
+++ b/modules/remote_bitrate_estimator/bwe_defines.cc
@@ -23,7 +23,7 @@
}
DataRate GetMinBitrate() {
- return DataRate::bps(GetMinBitrateBps());
+ return DataRate::BitsPerSec(GetMinBitrateBps());
}
} // namespace congestion_controller
diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
index 3ab77a7..b146d00 100644
--- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.cc
@@ -27,7 +27,7 @@
absl::optional<DataRate> OptionalRateFromOptionalBps(
absl::optional<int> bitrate_bps) {
if (bitrate_bps) {
- return DataRate::bps(*bitrate_bps);
+ return DataRate::BitsPerSec(*bitrate_bps);
} else {
return absl::nullopt;
}
@@ -201,7 +201,7 @@
<< " bps. Mean send delta: " << best_it->send_mean_ms
<< " ms, mean recv delta: " << best_it->recv_mean_ms
<< " ms, num probes: " << best_it->count;
- remote_rate_.SetEstimate(DataRate::bps(probe_bitrate_bps),
+ remote_rate_.SetEstimate(DataRate::BitsPerSec(probe_bitrate_bps),
Timestamp::Millis(now_ms));
return ProbeResult::kBitrateUpdated;
}
@@ -335,9 +335,9 @@
} else if (detector_.State() == BandwidthUsage::kBwOverusing) {
absl::optional<uint32_t> incoming_rate =
incoming_bitrate_.Rate(arrival_time_ms);
- if (incoming_rate &&
- remote_rate_.TimeToReduceFurther(Timestamp::Millis(now_ms),
- DataRate::bps(*incoming_rate))) {
+ if (incoming_rate && remote_rate_.TimeToReduceFurther(
+ Timestamp::Millis(now_ms),
+ DataRate::BitsPerSec(*incoming_rate))) {
update_estimate = true;
}
}
@@ -426,6 +426,6 @@
// Called from both the configuration thread and the network thread. Shouldn't
// be called from the network thread in the future.
rtc::CritScope lock(&crit_);
- remote_rate_.SetMinBitrate(DataRate::bps(min_bitrate_bps));
+ remote_rate_.SetMinBitrate(DataRate::BitsPerSec(min_bitrate_bps));
}
} // namespace webrtc
diff --git a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
index 4d969d8..db3bbe9 100644
--- a/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
+++ b/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.cc
@@ -31,7 +31,7 @@
absl::optional<DataRate> OptionalRateFromOptionalBps(
absl::optional<int> bitrate_bps) {
if (bitrate_bps) {
- return DataRate::bps(*bitrate_bps);
+ return DataRate::BitsPerSec(*bitrate_bps);
} else {
return absl::nullopt;
}
@@ -143,10 +143,11 @@
if (estimator->detector.State() == BandwidthUsage::kBwOverusing) {
absl::optional<uint32_t> incoming_bitrate_bps =
incoming_bitrate_.Rate(now_ms);
- if (incoming_bitrate_bps && (prior_state != BandwidthUsage::kBwOverusing ||
- GetRemoteRate()->TimeToReduceFurther(
- Timestamp::Millis(now_ms),
- DataRate::bps(*incoming_bitrate_bps)))) {
+ if (incoming_bitrate_bps &&
+ (prior_state != BandwidthUsage::kBwOverusing ||
+ GetRemoteRate()->TimeToReduceFurther(
+ Timestamp::Millis(now_ms),
+ DataRate::BitsPerSec(*incoming_bitrate_bps)))) {
// The first overuse should immediately trigger a new estimate.
// We also have to update the estimate immediately if we are overusing
// and the target bitrate is too high compared to what we are receiving.
@@ -264,7 +265,7 @@
void RemoteBitrateEstimatorSingleStream::SetMinBitrate(int min_bitrate_bps) {
rtc::CritScope cs(&crit_sect_);
- remote_rate_->SetMinBitrate(DataRate::bps(min_bitrate_bps));
+ remote_rate_->SetMinBitrate(DataRate::BitsPerSec(min_bitrate_bps));
}
} // namespace webrtc
diff --git a/modules/remote_bitrate_estimator/remote_estimator_proxy.cc b/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
index b8ea77a..f044721 100644
--- a/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
+++ b/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
@@ -122,7 +122,7 @@
packet_result.sent_packet.send_time = abs_send_timestamp_;
// TODO(webrtc:10742): Take IP header and transport overhead into account.
packet_result.sent_packet.size =
- DataSize::bytes(header.headerLength + payload_size);
+ DataSize::Bytes(header.headerLength + payload_size);
packet_result.sent_packet.sequence_number = seq;
network_state_estimator_->OnReceivedPacket(packet_result);
}
diff --git a/modules/rtp_rtcp/source/rtcp_packet/remote_estimate.cc b/modules/rtp_rtcp/source/rtcp_packet/remote_estimate.cc
index 3f63bd5..ca59791 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/remote_estimate.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/remote_estimate.cc
@@ -25,7 +25,7 @@
static constexpr int kFieldValueSize = 3;
static constexpr int kFieldSize = 1 + kFieldValueSize;
-static constexpr DataRate kDataRateResolution = DataRate::KilobitsPerSec<1>();
+static constexpr DataRate kDataRateResolution = DataRate::KilobitsPerSec(1);
constexpr int64_t kMaxEncoded = (1 << (kFieldValueSize * 8)) - 1;
class DataRateSerializer {
diff --git a/modules/rtp_rtcp/source/rtcp_packet/remote_estimate_unittest.cc b/modules/rtp_rtcp/source/rtcp_packet/remote_estimate_unittest.cc
index bbeb227..bf0e0e2 100644
--- a/modules/rtp_rtcp/source/rtcp_packet/remote_estimate_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_packet/remote_estimate_unittest.cc
@@ -15,8 +15,8 @@
namespace rtcp {
TEST(RemoteEstimateTest, EncodesCapacityBounds) {
NetworkStateEstimate src;
- src.link_capacity_lower = DataRate::kbps(10);
- src.link_capacity_upper = DataRate::kbps(1000000);
+ src.link_capacity_lower = DataRate::KilobitsPerSec(10);
+ src.link_capacity_upper = DataRate::KilobitsPerSec(1000000);
rtc::Buffer data = GetRemoteEstimateSerializer()->Serialize(src);
NetworkStateEstimate dst;
EXPECT_TRUE(GetRemoteEstimateSerializer()->Parse(data, &dst));
@@ -28,7 +28,7 @@
NetworkStateEstimate src;
// White box testing: We know that the value is stored in an unsigned 24 int
// with kbps resolution. We expected it be represented as plus infinity.
- src.link_capacity_lower = DataRate::kbps(2 << 24);
+ src.link_capacity_lower = DataRate::KilobitsPerSec(2 << 24);
src.link_capacity_upper = DataRate::PlusInfinity();
rtc::Buffer data = GetRemoteEstimateSerializer()->Serialize(src);
@@ -46,10 +46,10 @@
// Since MinusInfinity can't be represented, the buffer should be empty.
EXPECT_EQ(data.size(), 0u);
NetworkStateEstimate dst;
- dst.link_capacity_lower = DataRate::kbps(300);
+ dst.link_capacity_lower = DataRate::KilobitsPerSec(300);
EXPECT_TRUE(GetRemoteEstimateSerializer()->Parse(data, &dst));
// The fields will be left unchanged by the parser as they were not encoded.
- EXPECT_EQ(dst.link_capacity_lower, DataRate::kbps(300));
+ EXPECT_EQ(dst.link_capacity_lower, DataRate::KilobitsPerSec(300));
EXPECT_TRUE(dst.link_capacity_upper.IsMinusInfinity());
}
} // namespace rtcp
diff --git a/modules/rtp_rtcp/source/rtp_sender_egress.cc b/modules/rtp_rtcp/source/rtp_sender_egress.cc
index fafd3ca..d34d7c6 100644
--- a/modules/rtp_rtcp/source/rtp_sender_egress.cc
+++ b/modules/rtp_rtcp/source/rtp_sender_egress.cc
@@ -213,13 +213,13 @@
DataRate RtpSenderEgress::SendBitrate() const {
rtc::CritScope cs(&lock_);
- return DataRate::bps(
+ return DataRate::BitsPerSec(
total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0));
}
DataRate RtpSenderEgress::NackOverheadRate() const {
rtc::CritScope cs(&lock_);
- return DataRate::bps(
+ return DataRate::BitsPerSec(
nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0));
}
diff --git a/modules/video_coding/codecs/h264/h264_encoder_impl.cc b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
index 53fac77..ffe852b 100644
--- a/modules/video_coding/codecs/h264/h264_encoder_impl.cc
+++ b/modules/video_coding/codecs/h264/h264_encoder_impl.cc
@@ -295,7 +295,7 @@
SimulcastRateAllocator init_allocator(codec_);
VideoBitrateAllocation allocation =
init_allocator.Allocate(VideoBitrateAllocationParameters(
- DataRate::kbps(codec_.startBitrate), codec_.maxFramerate));
+ DataRate::KilobitsPerSec(codec_.startBitrate), codec_.maxFramerate));
SetRates(RateControlParameters(allocation, codec_.maxFramerate));
return WEBRTC_VIDEO_CODEC_OK;
}
diff --git a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
index 70ffb42..492ff19 100644
--- a/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
+++ b/modules/video_coding/codecs/multiplex/multiplex_encoder_adapter.cc
@@ -242,7 +242,7 @@
bitrate_allocation,
static_cast<uint32_t>(encoders_.size() * parameters.framerate_fps),
parameters.bandwidth_allocation -
- DataRate::bps(augmenting_data_size_)));
+ DataRate::BitsPerSec(augmenting_data_size_)));
}
}
diff --git a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index a597dc4..af6da5e 100644
--- a/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -206,7 +206,7 @@
static_cast<double>(codec_settings_.maxFramerate);
// Set rates with no headroom.
- rate_settings.bandwidth_allocation = DataRate::bps(kBitrateBps);
+ rate_settings.bandwidth_allocation = DataRate::BitsPerSec(kBitrateBps);
EXPECT_CALL(
*vpx,
codec_enc_config_set(
@@ -221,7 +221,7 @@
encoder.SetRates(rate_settings);
// Set rates with max headroom.
- rate_settings.bandwidth_allocation = DataRate::bps(kBitrateBps * 2);
+ rate_settings.bandwidth_allocation = DataRate::BitsPerSec(kBitrateBps * 2);
EXPECT_CALL(
*vpx, codec_enc_config_set(
_, AllOf(Field(&vpx_codec_enc_cfg_t::rc_target_bitrate,
@@ -235,7 +235,8 @@
encoder.SetRates(rate_settings);
// Set rates with headroom half way.
- rate_settings.bandwidth_allocation = DataRate::bps((3 * kBitrateBps) / 2);
+ rate_settings.bandwidth_allocation =
+ DataRate::BitsPerSec((3 * kBitrateBps) / 2);
EXPECT_CALL(
*vpx,
codec_enc_config_set(
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator.cc b/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
index 7d5c724..cc9a0d8 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator.cc
@@ -62,9 +62,9 @@
// max bitrate constraint, try to pass it forward to the next one.
DataRate excess_rate = DataRate::Zero();
for (size_t sl_idx = 0; sl_idx < spatial_layer_rates.size(); ++sl_idx) {
- DataRate min_rate = DataRate::kbps(
+ DataRate min_rate = DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + sl_idx].minBitrate);
- DataRate max_rate = DataRate::kbps(
+ DataRate max_rate = DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + sl_idx].maxBitrate);
DataRate layer_rate = spatial_layer_rates[sl_idx] + excess_rate;
@@ -125,7 +125,7 @@
size_t first_active_layer,
size_t num_active_layers) {
if (num_active_layers == 1) {
- return DataRate::kbps(codec.spatialLayers[0].minBitrate);
+ return DataRate::KilobitsPerSec(codec.spatialLayers[0].minBitrate);
}
if (codec.mode == VideoCodecMode::kRealtimeVideo) {
@@ -133,19 +133,19 @@
DataRate upper_bound = DataRate::Zero();
if (num_active_layers > 1) {
for (size_t i = 0; i < num_active_layers - 1; ++i) {
- lower_bound += DataRate::kbps(
+ lower_bound += DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + i].minBitrate);
- upper_bound += DataRate::kbps(
+ upper_bound += DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + i].maxBitrate);
}
}
- upper_bound +=
- DataRate::kbps(codec.spatialLayers[num_active_layers - 1].minBitrate);
+ upper_bound += DataRate::KilobitsPerSec(
+ codec.spatialLayers[num_active_layers - 1].minBitrate);
// Do a binary search until upper and lower bound is the highest bitrate for
// |num_active_layers| - 1 layers and lowest bitrate for |num_active_layers|
// layers respectively.
- while (upper_bound - lower_bound > DataRate::bps(1)) {
+ while (upper_bound - lower_bound > DataRate::BitsPerSec(1)) {
DataRate try_rate = (lower_bound + upper_bound) / 2;
if (AdjustAndVerify(codec, first_active_layer,
SplitBitrate(num_active_layers, try_rate,
@@ -160,10 +160,10 @@
} else {
DataRate toggling_rate = DataRate::Zero();
for (size_t i = 0; i < num_active_layers - 1; ++i) {
- toggling_rate += DataRate::kbps(
+ toggling_rate += DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + i].targetBitrate);
}
- toggling_rate += DataRate::kbps(
+ toggling_rate += DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + num_active_layers - 1]
.minBitrate);
return toggling_rate;
@@ -199,7 +199,8 @@
VideoBitrateAllocationParameters parameters) {
DataRate total_bitrate = parameters.total_bitrate;
if (codec_.maxBitrate != 0) {
- total_bitrate = std::min(total_bitrate, DataRate::kbps(codec_.maxBitrate));
+ total_bitrate =
+ std::min(total_bitrate, DataRate::KilobitsPerSec(codec_.maxBitrate));
}
if (codec_.spatialLayers[0].targetBitrate == 0) {
@@ -324,7 +325,8 @@
if (num_spatial_layers == 0 ||
total_bitrate <
- DataRate::kbps(codec_.spatialLayers[first_active_layer].minBitrate)) {
+ DataRate::KilobitsPerSec(
+ codec_.spatialLayers[first_active_layer].minBitrate)) {
// Always enable at least one layer.
bitrate_allocation.SetBitrate(first_active_layer, 0, total_bitrate.bps());
return bitrate_allocation;
@@ -336,9 +338,9 @@
for (sl_idx = first_active_layer;
sl_idx < first_active_layer + num_spatial_layers; ++sl_idx) {
const DataRate min_rate =
- DataRate::kbps(codec_.spatialLayers[sl_idx].minBitrate);
+ DataRate::KilobitsPerSec(codec_.spatialLayers[sl_idx].minBitrate);
const DataRate target_rate =
- DataRate::kbps(codec_.spatialLayers[sl_idx].targetBitrate);
+ DataRate::KilobitsPerSec(codec_.spatialLayers[sl_idx].targetBitrate);
if (allocated_rate + min_rate > total_bitrate) {
// Use stable rate to determine if layer should be enabled.
@@ -352,9 +354,9 @@
if (sl_idx > 0 && total_bitrate - allocated_rate > DataRate::Zero()) {
// Add leftover to the last allocated layer.
- top_layer_rate =
- std::min(top_layer_rate + (total_bitrate - allocated_rate),
- DataRate::kbps(codec_.spatialLayers[sl_idx - 1].maxBitrate));
+ top_layer_rate = std::min(
+ top_layer_rate + (total_bitrate - allocated_rate),
+ DataRate::KilobitsPerSec(codec_.spatialLayers[sl_idx - 1].maxBitrate));
bitrate_allocation.SetBitrate(sl_idx - 1, 0, top_layer_rate.bps());
}
@@ -385,12 +387,13 @@
DataRate max_bitrate = DataRate::Zero();
for (size_t sl_idx = 0; sl_idx < num_spatial_layers; ++sl_idx) {
- max_bitrate += DataRate::kbps(
+ max_bitrate += DataRate::KilobitsPerSec(
codec.spatialLayers[first_active_layer + sl_idx].maxBitrate);
}
if (codec.maxBitrate != 0) {
- max_bitrate = std::min(max_bitrate, DataRate::kbps(codec.maxBitrate));
+ max_bitrate =
+ std::min(max_bitrate, DataRate::KilobitsPerSec(codec.maxBitrate));
}
return max_bitrate;
diff --git a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
index 9635eae..7318592 100644
--- a/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
+++ b/modules/video_coding/codecs/vp9/svc_rate_allocator_unittest.cc
@@ -259,8 +259,8 @@
// Predetermined constants indicating the min bitrate needed for two and three
// layers to be enabled respectively, using the config from Configure() with
// 1280x720 resolution and three spatial layers.
- const DataRate kTwoLayerMinRate = DataRate::bps(299150);
- const DataRate kThreeLayerMinRate = DataRate::bps(891052);
+ const DataRate kTwoLayerMinRate = DataRate::BitsPerSec(299150);
+ const DataRate kThreeLayerMinRate = DataRate::BitsPerSec(891052);
VideoCodec codec = Configure(1280, 720, 3, 1, false);
absl::InlinedVector<DataRate, kMaxSpatialLayers> layer_start_bitrates =
@@ -283,14 +283,14 @@
TEST_P(SvcRateAllocatorTestParametrizedContentType, MaxBitrate) {
VideoCodec codec = Configure(1280, 720, 3, 1, is_screen_sharing_);
EXPECT_EQ(SvcRateAllocator::GetMaxBitrate(codec),
- DataRate::kbps(codec.spatialLayers[0].maxBitrate +
- codec.spatialLayers[1].maxBitrate +
- codec.spatialLayers[2].maxBitrate));
+ DataRate::KilobitsPerSec(codec.spatialLayers[0].maxBitrate +
+ codec.spatialLayers[1].maxBitrate +
+ codec.spatialLayers[2].maxBitrate));
// Deactivate middle layer. This causes deactivation of top layer as well.
codec.spatialLayers[1].active = false;
EXPECT_EQ(SvcRateAllocator::GetMaxBitrate(codec),
- DataRate::kbps(codec.spatialLayers[0].maxBitrate));
+ DataRate::KilobitsPerSec(codec.spatialLayers[0].maxBitrate));
}
TEST_P(SvcRateAllocatorTestParametrizedContentType, PaddingBitrate) {
@@ -349,12 +349,13 @@
const DataRate min_rate_three_layers = start_rates[2];
const DataRate max_rate_one_layer =
- DataRate::kbps(codec.spatialLayers[0].maxBitrate);
+ DataRate::KilobitsPerSec(codec.spatialLayers[0].maxBitrate);
const DataRate max_rate_two_layers =
- is_screen_sharing_ ? DataRate::kbps(codec.spatialLayers[0].targetBitrate +
- codec.spatialLayers[1].maxBitrate)
- : DataRate::kbps(codec.spatialLayers[0].maxBitrate +
- codec.spatialLayers[1].maxBitrate);
+ is_screen_sharing_
+ ? DataRate::KilobitsPerSec(codec.spatialLayers[0].targetBitrate +
+ codec.spatialLayers[1].maxBitrate)
+ : DataRate::KilobitsPerSec(codec.spatialLayers[0].maxBitrate +
+ codec.spatialLayers[1].maxBitrate);
SvcRateAllocator allocator = SvcRateAllocator(codec);
@@ -368,12 +369,12 @@
// Two layers, stable bitrate too low for two layers.
allocation = allocator.Allocate(VideoBitrateAllocationParameters(
/*total_bitrate=*/min_rate_two_layers,
- /*stable_bitrate=*/min_rate_two_layers - DataRate::bps(1),
+ /*stable_bitrate=*/min_rate_two_layers - DataRate::BitsPerSec(1),
/*fps=*/30.0));
EXPECT_FALSE(allocation.IsSpatialLayerUsed(1));
- EXPECT_EQ(
- DataRate::bps(allocation.get_sum_bps()),
- std::min(min_rate_two_layers - DataRate::bps(1), max_rate_one_layer));
+ EXPECT_EQ(DataRate::BitsPerSec(allocation.get_sum_bps()),
+ std::min(min_rate_two_layers - DataRate::BitsPerSec(1),
+ max_rate_one_layer));
// Three layers, stable and target equal.
allocation = allocator.Allocate(VideoBitrateAllocationParameters(
@@ -385,12 +386,12 @@
// Three layers, stable bitrate too low for three layers.
allocation = allocator.Allocate(VideoBitrateAllocationParameters(
/*total_bitrate=*/min_rate_three_layers,
- /*stable_bitrate=*/min_rate_three_layers - DataRate::bps(1),
+ /*stable_bitrate=*/min_rate_three_layers - DataRate::BitsPerSec(1),
/*fps=*/30.0));
EXPECT_FALSE(allocation.IsSpatialLayerUsed(2));
- EXPECT_EQ(
- DataRate::bps(allocation.get_sum_bps()),
- std::min(min_rate_three_layers - DataRate::bps(1), max_rate_two_layers));
+ EXPECT_EQ(DataRate::BitsPerSec(allocation.get_sum_bps()),
+ std::min(min_rate_three_layers - DataRate::BitsPerSec(1),
+ max_rate_two_layers));
}
TEST_P(SvcRateAllocatorTestParametrizedContentType,
@@ -444,7 +445,8 @@
// Going below min for two layers, second layer should turn off again.
allocation = allocator.Allocate(VideoBitrateAllocationParameters(
/*total_bitrate=*/max_bitrate,
- /*stable_bitrate=*/min_rate_two_layers - DataRate::bps(1), /*fps=*/30.0));
+ /*stable_bitrate=*/min_rate_two_layers - DataRate::BitsPerSec(1),
+ /*fps=*/30.0));
EXPECT_TRUE(allocation.IsSpatialLayerUsed(0));
EXPECT_FALSE(allocation.IsSpatialLayerUsed(1));
EXPECT_FALSE(allocation.IsSpatialLayerUsed(2));
@@ -476,7 +478,7 @@
// Going below min for three layers, third layer should turn off again.
allocation = allocator.Allocate(VideoBitrateAllocationParameters(
/*total_bitrate=*/max_bitrate,
- /*stable_bitrate=*/min_rate_three_layers - DataRate::bps(1),
+ /*stable_bitrate=*/min_rate_three_layers - DataRate::BitsPerSec(1),
/*fps=*/30.0));
EXPECT_TRUE(allocation.IsSpatialLayerUsed(0));
EXPECT_TRUE(allocation.IsSpatialLayerUsed(1));
diff --git a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
index 1a237ca..78411eb 100644
--- a/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
+++ b/modules/video_coding/codecs/vp9/test/vp9_impl_unittest.cc
@@ -1667,7 +1667,7 @@
// Set 300kbps target with 100% headroom.
VideoEncoder::RateControlParameters params;
- params.bandwidth_allocation = DataRate::bps(300000);
+ params.bandwidth_allocation = DataRate::BitsPerSec(300000);
params.bitrate.SetBitrate(0, 0, params.bandwidth_allocation.bps());
params.framerate_fps = 30.0;
diff --git a/modules/video_coding/utility/simulcast_rate_allocator.cc b/modules/video_coding/utility/simulcast_rate_allocator.cc
index f2a9012..fef74cd 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator.cc
@@ -87,7 +87,7 @@
DataRate left_in_stable_allocation = stable_bitrate;
if (codec_.maxBitrate) {
- DataRate max_rate = DataRate::kbps(codec_.maxBitrate);
+ DataRate max_rate = DataRate::KilobitsPerSec(codec_.maxBitrate);
left_in_total_allocation = std::min(left_in_total_allocation, max_rate);
left_in_stable_allocation = std::min(left_in_stable_allocation, max_rate);
}
@@ -97,7 +97,8 @@
if (codec_.active) {
allocated_bitrates->SetBitrate(
0, 0,
- std::max(DataRate::kbps(codec_.minBitrate), left_in_total_allocation)
+ std::max(DataRate::KilobitsPerSec(codec_.minBitrate),
+ left_in_total_allocation)
.bps());
}
return;
@@ -129,7 +130,7 @@
// Always allocate enough bitrate for the minimum bitrate of the first
// active layer. Suspending below min bitrate is controlled outside the
// codec implementation and is not overridden by this.
- DataRate min_rate = DataRate::kbps(
+ DataRate min_rate = DataRate::KilobitsPerSec(
codec_.simulcastStream[layer_index[active_layer]].minBitrate);
left_in_total_allocation = std::max(left_in_total_allocation, min_rate);
left_in_stable_allocation = std::max(left_in_stable_allocation, min_rate);
@@ -157,8 +158,8 @@
}
// If we can't allocate to the current layer we can't allocate to higher
// layers because they require a higher minimum bitrate.
- DataRate min_bitrate = DataRate::kbps(stream.minBitrate);
- DataRate target_bitrate = DataRate::kbps(stream.targetBitrate);
+ DataRate min_bitrate = DataRate::KilobitsPerSec(stream.minBitrate);
+ DataRate target_bitrate = DataRate::KilobitsPerSec(stream.targetBitrate);
double hysteresis_factor =
codec_.mode == VideoCodecMode::kRealtimeVideo
? stable_rate_settings_.GetVideoHysteresisFactor()
@@ -193,11 +194,11 @@
// better idea of possible performance implications.
if (left_in_total_allocation > DataRate::Zero()) {
const SimulcastStream& stream = codec_.simulcastStream[top_active_layer];
- DataRate initial_layer_rate =
- DataRate::bps(allocated_bitrates->GetSpatialLayerSum(top_active_layer));
- DataRate additional_allocation =
- std::min(left_in_total_allocation,
- DataRate::kbps(stream.maxBitrate) - initial_layer_rate);
+ DataRate initial_layer_rate = DataRate::BitsPerSec(
+ allocated_bitrates->GetSpatialLayerSum(top_active_layer));
+ DataRate additional_allocation = std::min(
+ left_in_total_allocation,
+ DataRate::KilobitsPerSec(stream.maxBitrate) - initial_layer_rate);
allocated_bitrates->SetBitrate(
top_active_layer, 0,
(initial_layer_rate + additional_allocation).bps());
diff --git a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
index e85ae3b..db104c4 100644
--- a/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
+++ b/modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
@@ -133,7 +133,7 @@
VideoBitrateAllocation GetAllocation(uint32_t target_bitrate) {
return allocator_->Allocate(VideoBitrateAllocationParameters(
- DataRate::kbps(target_bitrate), kDefaultFrameRate));
+ DataRate::KilobitsPerSec(target_bitrate), kDefaultFrameRate));
}
VideoBitrateAllocation GetAllocation(DataRate target_rate,
@@ -143,15 +143,18 @@
}
DataRate MinRate(size_t layer_index) const {
- return DataRate::kbps(codec_.simulcastStream[layer_index].minBitrate);
+ return DataRate::KilobitsPerSec(
+ codec_.simulcastStream[layer_index].minBitrate);
}
DataRate TargetRate(size_t layer_index) const {
- return DataRate::kbps(codec_.simulcastStream[layer_index].targetBitrate);
+ return DataRate::KilobitsPerSec(
+ codec_.simulcastStream[layer_index].targetBitrate);
}
DataRate MaxRate(size_t layer_index) const {
- return DataRate::kbps(codec_.simulcastStream[layer_index].maxBitrate);
+ return DataRate::KilobitsPerSec(
+ codec_.simulcastStream[layer_index].maxBitrate);
}
protected:
@@ -590,8 +593,8 @@
// Let stable rate go to a bitrate below what is needed for two streams.
uint32_t expected[] = {MaxRate(0).kbps<uint32_t>(), 0};
ExpectEqual(expected,
- GetAllocation(volatile_rate,
- TargetRate(0) + MinRate(1) - DataRate::bps(1)));
+ GetAllocation(volatile_rate, TargetRate(0) + MinRate(1) -
+ DataRate::BitsPerSec(1)));
}
{
diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc
index 4523121..4237b47 100644
--- a/pc/peer_connection_factory.cc
+++ b/pc/peer_connection_factory.cc
@@ -364,9 +364,12 @@
call_config.audio_state =
channel_manager_->media_engine()->voice().GetAudioState();
- FieldTrialParameter<DataRate> min_bandwidth("min", DataRate::kbps(30));
- FieldTrialParameter<DataRate> start_bandwidth("start", DataRate::kbps(300));
- FieldTrialParameter<DataRate> max_bandwidth("max", DataRate::kbps(2000));
+ FieldTrialParameter<DataRate> min_bandwidth("min",
+ DataRate::KilobitsPerSec(30));
+ FieldTrialParameter<DataRate> start_bandwidth("start",
+ DataRate::KilobitsPerSec(300));
+ FieldTrialParameter<DataRate> max_bandwidth("max",
+ DataRate::KilobitsPerSec(2000));
ParseFieldTrial({&min_bandwidth, &start_bandwidth, &max_bandwidth},
trials_->Lookup("WebRTC-PcFactoryDefaultBitrates"));
diff --git a/rtc_base/experiments/field_trial_units.cc b/rtc_base/experiments/field_trial_units.cc
index 8111225..5aceab7 100644
--- a/rtc_base/experiments/field_trial_units.cc
+++ b/rtc_base/experiments/field_trial_units.cc
@@ -51,9 +51,9 @@
absl::optional<ValueWithUnit> result = ParseValueWithUnit(str);
if (result) {
if (result->unit.empty() || result->unit == "kbps") {
- return DataRate::kbps(result->value);
+ return DataRate::KilobitsPerSec(result->value);
} else if (result->unit == "bps") {
- return DataRate::bps(result->value);
+ return DataRate::BitsPerSec(result->value);
}
}
return absl::nullopt;
@@ -64,7 +64,7 @@
absl::optional<ValueWithUnit> result = ParseValueWithUnit(str);
if (result) {
if (result->unit.empty() || result->unit == "bytes")
- return DataSize::bytes(result->value);
+ return DataSize::Bytes(result->value);
}
return absl::nullopt;
}
diff --git a/rtc_base/experiments/field_trial_units_unittest.cc b/rtc_base/experiments/field_trial_units_unittest.cc
index adb62ba..1f46d6f 100644
--- a/rtc_base/experiments/field_trial_units_unittest.cc
+++ b/rtc_base/experiments/field_trial_units_unittest.cc
@@ -19,7 +19,7 @@
namespace {
struct DummyExperiment {
FieldTrialParameter<DataRate> target_rate =
- FieldTrialParameter<DataRate>("t", DataRate::kbps(100));
+ FieldTrialParameter<DataRate>("t", DataRate::KilobitsPerSec(100));
FieldTrialParameter<TimeDelta> period =
FieldTrialParameter<TimeDelta>("p", TimeDelta::Millis(100));
FieldTrialOptional<DataSize> max_buffer =
@@ -33,20 +33,20 @@
TEST(FieldTrialParserUnitsTest, FallsBackToDefaults) {
DummyExperiment exp("");
- EXPECT_EQ(exp.target_rate.Get(), DataRate::kbps(100));
+ EXPECT_EQ(exp.target_rate.Get(), DataRate::KilobitsPerSec(100));
EXPECT_FALSE(exp.max_buffer.GetOptional().has_value());
EXPECT_EQ(exp.period.Get(), TimeDelta::Millis(100));
}
TEST(FieldTrialParserUnitsTest, ParsesUnitParameters) {
DummyExperiment exp("t:300kbps,b:5bytes,p:300ms");
- EXPECT_EQ(exp.target_rate.Get(), DataRate::kbps(300));
- EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::bytes(5));
+ EXPECT_EQ(exp.target_rate.Get(), DataRate::KilobitsPerSec(300));
+ EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::Bytes(5));
EXPECT_EQ(exp.period.Get(), TimeDelta::Millis(300));
}
TEST(FieldTrialParserUnitsTest, ParsesDefaultUnitParameters) {
DummyExperiment exp("t:300,b:5,p:300");
- EXPECT_EQ(exp.target_rate.Get(), DataRate::kbps(300));
- EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::bytes(5));
+ EXPECT_EQ(exp.target_rate.Get(), DataRate::KilobitsPerSec(300));
+ EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::Bytes(5));
EXPECT_EQ(exp.period.Get(), TimeDelta::Millis(300));
}
TEST(FieldTrialParserUnitsTest, ParsesInfinityParameter) {
@@ -56,18 +56,19 @@
}
TEST(FieldTrialParserUnitsTest, ParsesOtherUnitParameters) {
DummyExperiment exp("t:300bps,p:0.3 seconds,b:8 bytes");
- EXPECT_EQ(exp.target_rate.Get(), DataRate::bps(300));
- EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::bytes(8));
+ EXPECT_EQ(exp.target_rate.Get(), DataRate::BitsPerSec(300));
+ EXPECT_EQ(*exp.max_buffer.GetOptional(), DataSize::Bytes(8));
EXPECT_EQ(exp.period.Get(), TimeDelta::Millis(300));
}
TEST(FieldTrialParserUnitsTest, IgnoresOutOfRange) {
- FieldTrialConstrained<DataRate> rate("r", DataRate::kbps(30),
- DataRate::kbps(10), DataRate::kbps(100));
+ FieldTrialConstrained<DataRate> rate("r", DataRate::KilobitsPerSec(30),
+ DataRate::KilobitsPerSec(10),
+ DataRate::KilobitsPerSec(100));
FieldTrialConstrained<TimeDelta> delta("d", TimeDelta::Millis(30),
TimeDelta::Millis(10),
TimeDelta::Millis(100));
FieldTrialConstrained<DataSize> size(
- "s", DataSize::bytes(30), DataSize::bytes(10), DataSize::bytes(100));
+ "s", DataSize::Bytes(30), DataSize::Bytes(10), DataSize::Bytes(100));
ParseFieldTrial({&rate, &delta, &size}, "r:0,d:0,s:0");
EXPECT_EQ(rate->kbps(), 30);
EXPECT_EQ(delta->ms(), 30);
diff --git a/rtc_base/experiments/min_video_bitrate_experiment.cc b/rtc_base/experiments/min_video_bitrate_experiment.cc
index ee62d2e..11450d0 100644
--- a/rtc_base/experiments/min_video_bitrate_experiment.cc
+++ b/rtc_base/experiments/min_video_bitrate_experiment.cc
@@ -61,7 +61,7 @@
const absl::optional<int> fallback_min_bitrate_bps =
GetFallbackMinBpsFromFieldTrial(type);
if (fallback_min_bitrate_bps) {
- return DataRate::bps(*fallback_min_bitrate_bps);
+ return DataRate::BitsPerSec(*fallback_min_bitrate_bps);
}
if (webrtc::field_trial::IsEnabled(kMinVideoBitrateExperiment)) {
diff --git a/rtc_base/experiments/min_video_bitrate_experiment_unittest.cc b/rtc_base/experiments/min_video_bitrate_experiment_unittest.cc
index ca0550d..9792bad 100644
--- a/rtc_base/experiments/min_video_bitrate_experiment_unittest.cc
+++ b/rtc_base/experiments/min_video_bitrate_experiment_unittest.cc
@@ -59,16 +59,16 @@
"WebRTC-Video-MinVideoBitrate/Enabled,br:123kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(
GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecMultiplex),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
}
TEST(GetExperimentalMinVideoBitrateTest, BrTrumpsSpecificCodecConfigs) {
@@ -77,16 +77,16 @@
"Enabled,br:123kbps,vp8_br:100kbps,vp9_br:200kbps,h264_br:300kbps/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
EXPECT_EQ(
GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecMultiplex),
- absl::make_optional(DataRate::kbps(123)));
+ absl::make_optional(DataRate::KilobitsPerSec(123)));
}
TEST(GetExperimentalMinVideoBitrateTest,
@@ -116,11 +116,11 @@
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric),
absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8),
- absl::make_optional(DataRate::kbps(100)));
+ absl::make_optional(DataRate::KilobitsPerSec(100)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9),
- absl::make_optional(DataRate::kbps(200)));
+ absl::make_optional(DataRate::KilobitsPerSec(200)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264),
- absl::make_optional(DataRate::kbps(300)));
+ absl::make_optional(DataRate::KilobitsPerSec(300)));
EXPECT_EQ(
GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecMultiplex),
absl::nullopt);
@@ -135,7 +135,7 @@
"Enabled-444444,555555,666666/");
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP8),
- absl::make_optional(DataRate::bps(666666)));
+ absl::make_optional(DataRate::BitsPerSec(666666)));
}
TEST(GetExperimentalMinVideoBitrateTest,
@@ -149,9 +149,9 @@
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecGeneric),
absl::nullopt);
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecVP9),
- absl::make_optional(DataRate::kbps(200)));
+ absl::make_optional(DataRate::KilobitsPerSec(200)));
EXPECT_EQ(GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecH264),
- absl::make_optional(DataRate::kbps(300)));
+ absl::make_optional(DataRate::KilobitsPerSec(300)));
EXPECT_EQ(
GetExperimentalMinVideoBitrate(VideoCodecType::kVideoCodecMultiplex),
absl::nullopt);
diff --git a/rtc_base/numerics/sample_stats.cc b/rtc_base/numerics/sample_stats.cc
index 4b33d97..6000b2b 100644
--- a/rtc_base/numerics/sample_stats.cc
+++ b/rtc_base/numerics/sample_stats.cc
@@ -118,11 +118,11 @@
}
DataRate SampleStats<DataRate>::Max() {
- return DataRate::bps(stats_.Max());
+ return DataRate::BitsPerSec(stats_.Max());
}
DataRate SampleStats<DataRate>::Mean() {
- return DataRate::bps(stats_.Mean());
+ return DataRate::BitsPerSec(stats_.Mean());
}
DataRate SampleStats<DataRate>::Median() {
@@ -130,19 +130,19 @@
}
DataRate SampleStats<DataRate>::Quantile(double quantile) {
- return DataRate::bps(stats_.Quantile(quantile));
+ return DataRate::BitsPerSec(stats_.Quantile(quantile));
}
DataRate SampleStats<DataRate>::Min() {
- return DataRate::bps(stats_.Min());
+ return DataRate::BitsPerSec(stats_.Min());
}
DataRate SampleStats<DataRate>::Variance() {
- return DataRate::bps(stats_.Variance());
+ return DataRate::BitsPerSec(stats_.Variance());
}
DataRate SampleStats<DataRate>::StandardDeviation() {
- return DataRate::bps(stats_.StandardDeviation());
+ return DataRate::BitsPerSec(stats_.StandardDeviation());
}
int SampleStats<DataRate>::Count() {
diff --git a/rtc_tools/rtc_event_log_visualizer/analyzer.cc b/rtc_tools/rtc_event_log_visualizer/analyzer.cc
index f972f47..bd9f56d 100644
--- a/rtc_tools/rtc_event_log_visualizer/analyzer.cc
+++ b/rtc_tools/rtc_event_log_visualizer/analyzer.cc
@@ -1229,7 +1229,8 @@
static const uint32_t kDefaultStartBitrateBps = 300000;
NetworkControllerConfig cc_config;
cc_config.constraints.at_time = Timestamp::Micros(clock.TimeInMicroseconds());
- cc_config.constraints.starting_rate = DataRate::bps(kDefaultStartBitrateBps);
+ cc_config.constraints.starting_rate =
+ DataRate::BitsPerSec(kDefaultStartBitrateBps);
cc_config.event_log = &null_event_log;
auto goog_cc = factory.Create(cc_config);
diff --git a/rtc_tools/rtc_event_log_visualizer/log_simulation.cc b/rtc_tools/rtc_event_log_visualizer/log_simulation.cc
index 07752e7..d3016e8 100644
--- a/rtc_tools/rtc_event_log_visualizer/log_simulation.cc
+++ b/rtc_tools/rtc_event_log_visualizer/log_simulation.cc
@@ -33,8 +33,8 @@
if (last_process_.IsInfinite()) {
NetworkControllerConfig config;
config.constraints.at_time = to_time;
- config.constraints.min_data_rate = DataRate::kbps(30);
- config.constraints.starting_rate = DataRate::kbps(300);
+ config.constraints.min_data_rate = DataRate::KilobitsPerSec(30);
+ config.constraints.starting_rate = DataRate::KilobitsPerSec(300);
config.event_log = &null_event_log_;
controller_ = factory_->Create(config);
}
@@ -168,8 +168,8 @@
ProcessUntil(log_time);
NetworkRouteChange msg;
msg.at_time = log_time;
- msg.constraints.min_data_rate = DataRate::kbps(30);
- msg.constraints.starting_rate = DataRate::kbps(300);
+ msg.constraints.min_data_rate = DataRate::KilobitsPerSec(30);
+ msg.constraints.starting_rate = DataRate::KilobitsPerSec(300);
msg.constraints.at_time = log_time;
HandleStateUpdate(controller_->OnNetworkRouteChange(msg));
}
diff --git a/test/network/cross_traffic.h b/test/network/cross_traffic.h
index b38ccfa..942b863 100644
--- a/test/network/cross_traffic.h
+++ b/test/network/cross_traffic.h
@@ -29,8 +29,8 @@
struct RandomWalkConfig {
int random_seed = 1;
- DataRate peak_rate = DataRate::kbps(100);
- DataSize min_packet_size = DataSize::bytes(200);
+ DataRate peak_rate = DataRate::KilobitsPerSec(100);
+ DataSize min_packet_size = DataSize::Bytes(200);
TimeDelta min_packet_interval = TimeDelta::Millis(1);
TimeDelta update_interval = TimeDelta::Millis(200);
double variance = 0.6;
@@ -63,8 +63,8 @@
};
struct PulsedPeaksConfig {
- DataRate peak_rate = DataRate::kbps(100);
- DataSize min_packet_size = DataSize::bytes(200);
+ DataRate peak_rate = DataRate::KilobitsPerSec(100);
+ DataSize min_packet_size = DataSize::Bytes(200);
TimeDelta min_packet_interval = TimeDelta::Millis(1);
TimeDelta send_duration = TimeDelta::Millis(100);
TimeDelta hold_duration = TimeDelta::Millis(2000);
@@ -150,7 +150,7 @@
};
struct FakeTcpConfig {
- DataSize packet_size = DataSize::bytes(1200);
+ DataSize packet_size = DataSize::Bytes(1200);
DataSize send_limit = DataSize::PlusInfinity();
TimeDelta process_interval = TimeDelta::Millis(200);
TimeDelta packet_timeout = TimeDelta::Seconds(1);
diff --git a/test/network/cross_traffic_unittest.cc b/test/network/cross_traffic_unittest.cc
index 768e59d..a3c7b42 100644
--- a/test/network/cross_traffic_unittest.cc
+++ b/test/network/cross_traffic_unittest.cc
@@ -70,8 +70,8 @@
TrafficRoute traffic(&fixture.clock, &fixture.counter, &fixture.endpoint);
PulsedPeaksConfig config;
- config.peak_rate = DataRate::kbps(1000);
- config.min_packet_size = DataSize::bytes(1);
+ config.peak_rate = DataRate::KilobitsPerSec(1000);
+ config.min_packet_size = DataSize::Bytes(1);
config.min_packet_interval = TimeDelta::Millis(25);
config.send_duration = TimeDelta::Millis(500);
config.hold_duration = TimeDelta::Millis(250);
@@ -95,8 +95,8 @@
TrafficRoute traffic(&fixture.clock, &fixture.counter, &fixture.endpoint);
RandomWalkConfig config;
- config.peak_rate = DataRate::kbps(1000);
- config.min_packet_size = DataSize::bytes(1);
+ config.peak_rate = DataRate::KilobitsPerSec(1000);
+ config.min_packet_size = DataSize::Bytes(1);
config.min_packet_interval = TimeDelta::Millis(25);
config.update_interval = TimeDelta::Millis(500);
config.variance = 0.0;
diff --git a/test/network/feedback_generator.cc b/test/network/feedback_generator.cc
index f2e345f..f0903dd 100644
--- a/test/network/feedback_generator.cc
+++ b/test/network/feedback_generator.cc
@@ -37,7 +37,7 @@
void FeedbackGeneratorImpl::SendPacket(size_t size) {
SentPacket sent;
sent.send_time = Now();
- sent.size = DataSize::bytes(size);
+ sent.size = DataSize::Bytes(size);
sent.sequence_number = sequence_number_++;
route_.SendRequest(size, sent);
}
diff --git a/test/network/network_emulation.cc b/test/network/network_emulation.cc
index 88315a9..3cb3def 100644
--- a/test/network/network_emulation.cc
+++ b/test/network/network_emulation.cc
@@ -215,11 +215,11 @@
Timestamp current_time = clock_->CurrentTime();
if (stats_.first_packet_sent_time.IsInfinite()) {
stats_.first_packet_sent_time = current_time;
- stats_.first_sent_packet_size = DataSize::bytes(packet.ip_packet_size());
+ stats_.first_sent_packet_size = DataSize::Bytes(packet.ip_packet_size());
}
stats_.last_packet_sent_time = current_time;
stats_.packets_sent++;
- stats_.bytes_sent += DataSize::bytes(packet.ip_packet_size());
+ stats_.bytes_sent += DataSize::Bytes(packet.ip_packet_size());
router_.OnPacketReceived(std::move(packet));
});
@@ -291,7 +291,7 @@
RTC_LOG(INFO) << "Drop packet: no receiver registered in " << id_
<< " on port " << packet.to.port();
stats_.packets_dropped++;
- stats_.bytes_dropped += DataSize::bytes(packet.ip_packet_size());
+ stats_.bytes_dropped += DataSize::Bytes(packet.ip_packet_size());
return;
}
// Endpoint assumes frequent calls to bind and unbind methods, so it holds
@@ -328,11 +328,11 @@
if (stats_.first_packet_received_time.IsInfinite()) {
stats_.first_packet_received_time = current_time;
stats_.first_received_packet_size =
- DataSize::bytes(packet.ip_packet_size());
+ DataSize::Bytes(packet.ip_packet_size());
}
stats_.last_packet_received_time = current_time;
stats_.packets_received++;
- stats_.bytes_received += DataSize::bytes(packet.ip_packet_size());
+ stats_.bytes_received += DataSize::Bytes(packet.ip_packet_size());
}
EndpointsContainer::EndpointsContainer(
diff --git a/test/scenario/call_client.h b/test/scenario/call_client.h
index 1fbe256..803b4a8 100644
--- a/test/scenario/call_client.h
+++ b/test/scenario/call_client.h
@@ -104,7 +104,7 @@
ColumnPrinter StatsPrinter();
Call::Stats GetStats();
DataRate send_bandwidth() {
- return DataRate::bps(GetStats().send_bandwidth_bps);
+ return DataRate::BitsPerSec(GetStats().send_bandwidth_bps);
}
DataRate target_rate() const;
DataRate stable_target_rate() const;
diff --git a/test/scenario/scenario.cc b/test/scenario/scenario.cc
index 232cf06..c1c664a 100644
--- a/test/scenario/scenario.cc
+++ b/test/scenario/scenario.cc
@@ -131,8 +131,8 @@
CallClient* second,
std::vector<EmulatedNetworkNode*> return_link) {
return CreateRoutes(first, send_link,
- DataSize::bytes(PacketOverhead::kDefault), second,
- return_link, DataSize::bytes(PacketOverhead::kDefault));
+ DataSize::Bytes(PacketOverhead::kDefault), second,
+ return_link, DataSize::Bytes(PacketOverhead::kDefault));
}
CallClientPair* Scenario::CreateRoutes(
@@ -151,7 +151,7 @@
void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
std::vector<EmulatedNetworkNode*> over_nodes) {
- ChangeRoute(clients, over_nodes, DataSize::bytes(PacketOverhead::kDefault));
+ ChangeRoute(clients, over_nodes, DataSize::Bytes(PacketOverhead::kDefault));
}
void Scenario::ChangeRoute(std::pair<CallClient*, CallClient*> clients,
diff --git a/test/scenario/scenario_config.h b/test/scenario/scenario_config.h
index 0d1b845..fa998b8 100644
--- a/test/scenario/scenario_config.h
+++ b/test/scenario/scenario_config.h
@@ -42,9 +42,9 @@
Rates();
Rates(const Rates&);
~Rates();
- DataRate min_rate = DataRate::kbps(30);
- DataRate max_rate = DataRate::kbps(3000);
- DataRate start_rate = DataRate::kbps(300);
+ DataRate min_rate = DataRate::KilobitsPerSec(30);
+ DataRate max_rate = DataRate::KilobitsPerSec(3000);
+ DataRate start_rate = DataRate::KilobitsPerSec(300);
} rates;
NetworkControllerFactoryInterface* cc_factory = nullptr;
TimeDelta state_log_interval = TimeDelta::Millis(100);
@@ -61,10 +61,10 @@
~PacketStreamConfig();
int frame_rate = 30;
DataRate max_data_rate = DataRate::Infinity();
- DataSize max_packet_size = DataSize::bytes(1400);
- DataSize min_frame_size = DataSize::bytes(100);
+ DataSize max_packet_size = DataSize::Bytes(1400);
+ DataSize min_frame_size = DataSize::Bytes(100);
double keyframe_multiplier = 1;
- DataSize packet_overhead = DataSize::bytes(PacketOverhead::kDefault);
+ DataSize packet_overhead = DataSize::Bytes(PacketOverhead::kDefault);
};
struct VideoStreamConfig {
diff --git a/test/scenario/scenario_tests/bbr_performance.cc b/test/scenario/scenario_tests/bbr_performance.cc
index bf89e2c..0023d905 100644
--- a/test/scenario/scenario_tests/bbr_performance.cc
+++ b/test/scenario/scenario_tests/bbr_performance.cc
@@ -40,7 +40,7 @@
Scenario()
: random_seed("rs", 1),
return_traffic("ret"),
- capacity("bw", DataRate::kbps(300)),
+ capacity("bw", DataRate::KilobitsPerSec(300)),
propagation_delay("dl", TimeDelta::Millis(100)),
cross_traffic("ct", DataRate::Zero()),
delay_noise("dn", TimeDelta::Zero()),
@@ -60,7 +60,7 @@
Tuning()
: use_bbr("bbr"),
bbr_no_target_rate("notr"),
- bbr_initial_window("iw", DataSize::bytes(8000)),
+ bbr_initial_window("iw", DataSize::Bytes(8000)),
bbr_encoder_gain("eg", 0.8) {}
void Parse(std::string config_str) {
ParseFieldTrial(
@@ -151,8 +151,8 @@
if (conf_.tuning.use_bbr) {
call_config.transport.cc_factory = &bbr_factory;
}
- call_config.transport.rates.min_rate = DataRate::kbps(30);
- call_config.transport.rates.max_rate = DataRate::kbps(1800);
+ call_config.transport.rates.min_rate = DataRate::KilobitsPerSec(30);
+ call_config.transport.rates.max_rate = DataRate::KilobitsPerSec(1800);
CallClient* alice = s.CreateClient("send", call_config);
CallClient* bob = s.CreateClient("return", call_config);
@@ -168,12 +168,12 @@
VideoStreamPair* alice_video =
s.CreateVideoStream(route->forward(), [&](VideoStreamConfig* c) {
- c->encoder.fake.max_rate = DataRate::kbps(1800);
+ c->encoder.fake.max_rate = DataRate::KilobitsPerSec(1800);
});
s.CreateAudioStream(route->forward(), [&](AudioStreamConfig* c) {
if (conf_.tuning.use_bbr) {
c->stream.in_bandwidth_estimation = true;
- c->encoder.fixed_rate = DataRate::kbps(31);
+ c->encoder.fixed_rate = DataRate::KilobitsPerSec(31);
}
});
@@ -181,12 +181,12 @@
if (conf_.scenario.return_traffic) {
bob_video =
s.CreateVideoStream(route->reverse(), [&](VideoStreamConfig* c) {
- c->encoder.fake.max_rate = DataRate::kbps(1800);
+ c->encoder.fake.max_rate = DataRate::KilobitsPerSec(1800);
});
s.CreateAudioStream(route->reverse(), [&](AudioStreamConfig* c) {
if (conf_.tuning.use_bbr) {
c->stream.in_bandwidth_estimation = true;
- c->encoder.fixed_rate = DataRate::kbps(31);
+ c->encoder.fixed_rate = DataRate::KilobitsPerSec(31);
}
});
}
diff --git a/test/scenario/scenario_unittest.cc b/test/scenario/scenario_unittest.cc
index 46622db..1ee7484 100644
--- a/test/scenario/scenario_unittest.cc
+++ b/test/scenario/scenario_unittest.cc
@@ -22,7 +22,7 @@
std::atomic<bool> bitrate_changed(false);
Scenario s;
CallClientConfig call_client_config;
- call_client_config.transport.rates.start_rate = DataRate::kbps(300);
+ call_client_config.transport.rates.start_rate = DataRate::KilobitsPerSec(300);
auto* alice = s.CreateClient("alice", call_client_config);
auto* bob = s.CreateClient("bob", call_client_config);
NetworkSimulationConfig network_config;
@@ -35,8 +35,8 @@
s.CreateVideoStream(route->reverse(), video_stream_config);
AudioStreamConfig audio_stream_config;
- audio_stream_config.encoder.min_rate = DataRate::kbps(6);
- audio_stream_config.encoder.max_rate = DataRate::kbps(64);
+ audio_stream_config.encoder.min_rate = DataRate::KilobitsPerSec(6);
+ audio_stream_config.encoder.max_rate = DataRate::KilobitsPerSec(64);
audio_stream_config.encoder.allocate_bitrate = true;
audio_stream_config.stream.in_bandwidth_estimation = false;
s.CreateAudioStream(route->forward(), audio_stream_config);
@@ -66,7 +66,7 @@
auto* alice = s.CreateClient("alice", call_config);
auto* bob = s.CreateClient("bob", call_config);
NetworkSimulationConfig network_config;
- network_config.bandwidth = DataRate::kbps(1000);
+ network_config.bandwidth = DataRate::KilobitsPerSec(1000);
network_config.delay = TimeDelta::Millis(50);
auto alice_net = s.CreateSimulationNode(network_config);
auto bob_net = s.CreateSimulationNode(network_config);
diff --git a/test/scenario/stats_collection.cc b/test/scenario/stats_collection.cc
index e42d17e..54d4de5 100644
--- a/test/scenario/stats_collection.cc
+++ b/test/scenario/stats_collection.cc
@@ -167,7 +167,7 @@
kv.second.rtp_stats.fec.padding_bytes;
}
if (last_update_.IsFinite()) {
- auto fec_delta = DataSize::bytes(fec_bytes - last_fec_bytes_);
+ auto fec_delta = DataSize::Bytes(fec_bytes - last_fec_bytes_);
auto time_delta = at_time - last_update_;
stats_.fec_bitrate.AddSample(fec_delta / time_delta);
}
diff --git a/test/scenario/stats_collection_unittest.cc b/test/scenario/stats_collection_unittest.cc
index 1d8b7df..fae3365 100644
--- a/test/scenario/stats_collection_unittest.cc
+++ b/test/scenario/stats_collection_unittest.cc
@@ -46,7 +46,7 @@
{
Scenario s;
NetworkSimulationConfig good_network;
- good_network.bandwidth = DataRate::kbps(1000);
+ good_network.bandwidth = DataRate::KilobitsPerSec(1000);
CreateAnalyzedStream(&s, good_network, &analyzer, &stats);
s.RunFor(TimeDelta::Seconds(3));
}
@@ -67,7 +67,7 @@
{
Scenario s;
NetworkSimulationConfig bad_network;
- bad_network.bandwidth = DataRate::kbps(100);
+ bad_network.bandwidth = DataRate::KilobitsPerSec(100);
bad_network.loss_rate = 0.02;
CreateAnalyzedStream(&s, bad_network, &analyzer, &stats);
s.RunFor(TimeDelta::Seconds(3));
diff --git a/test/scenario/video_stream.cc b/test/scenario/video_stream.cc
index def6c20..e22432b 100644
--- a/test/scenario/video_stream.cc
+++ b/test/scenario/video_stream.cc
@@ -256,7 +256,8 @@
// TODO(srte): Base this on encoder capabilities.
encoder_config.max_bitrate_bps =
- config.encoder.max_data_rate.value_or(DataRate::kbps(10000)).bps();
+ config.encoder.max_data_rate.value_or(DataRate::KilobitsPerSec(10000))
+ .bps();
encoder_config.encoder_specific_settings =
CreateEncoderSpecificSettings(config);
diff --git a/video/encoder_bitrate_adjuster.cc b/video/encoder_bitrate_adjuster.cc
index 5af9128..e6c8739 100644
--- a/video/encoder_bitrate_adjuster.cc
+++ b/video/encoder_bitrate_adjuster.cc
@@ -109,7 +109,7 @@
LayerRateInfo& layer_info = layer_infos.back();
layer_info.target_rate =
- DataRate::bps(rates.bitrate.GetSpatialLayerSum(si));
+ DataRate::BitsPerSec(rates.bitrate.GetSpatialLayerSum(si));
// Adjustment is done per spatial layer only (not per temporal layer).
if (frames_since_layout_change_ < kMinFramesSinceLayoutChange) {
@@ -186,8 +186,8 @@
// Available link headroom that can be used to fill wanted overshoot.
DataRate available_headroom = DataRate::Zero();
if (utilize_bandwidth_headroom_) {
- available_headroom =
- rates.bandwidth_allocation - DataRate::bps(rates.bitrate.get_sum_bps());
+ available_headroom = rates.bandwidth_allocation -
+ DataRate::BitsPerSec(rates.bitrate.get_sum_bps());
}
// All wanted overshoots are satisfied in the same proportion based on
@@ -214,7 +214,7 @@
if (min_bitrates_bps_[si] > 0 &&
layer_info.target_rate > DataRate::Zero() &&
- DataRate::bps(min_bitrates_bps_[si]) < layer_info.target_rate) {
+ DataRate::BitsPerSec(min_bitrates_bps_[si]) < layer_info.target_rate) {
// Make sure rate adjuster doesn't push target bitrate below minimum.
utilization_factor =
std::min(utilization_factor, layer_info.target_rate.bps<double>() /
@@ -236,7 +236,7 @@
// Populate the adjusted allocation with determined utilization factor.
if (active_tls_[si] == 1 &&
layer_info.target_rate >
- DataRate::bps(rates.bitrate.GetBitrate(si, 0))) {
+ DataRate::BitsPerSec(rates.bitrate.GetBitrate(si, 0))) {
// Bitrate allocation indicates temporal layer usage, but encoder
// does not seem to support it. Pipe all bitrate into a single
// overshoot detector.
@@ -283,7 +283,7 @@
VideoEncoder::EncoderInfo::kMaxFramerateFraction;
overshoot_detectors_[si][ti]->SetTargetRate(
- DataRate::bps(layer_bitrate_bps),
+ DataRate::BitsPerSec(layer_bitrate_bps),
fps_fraction * rates.framerate_fps, now_ms);
}
}
diff --git a/video/encoder_bitrate_adjuster_unittest.cc b/video/encoder_bitrate_adjuster_unittest.cc
index 4a018c5..a521f1d 100644
--- a/video/encoder_bitrate_adjuster_unittest.cc
+++ b/video/encoder_bitrate_adjuster_unittest.cc
@@ -34,7 +34,7 @@
static_assert(kSequenceLength % 2 == 0, "Sequence length must be even.");
EncoderBitrateAdjusterTest()
- : target_bitrate_(DataRate::bps(kDefaultBitrateBps)),
+ : target_bitrate_(DataRate::BitsPerSec(kDefaultBitrateBps)),
target_framerate_fps_(kDefaultFrameRateFps),
tl_pattern_idx_{},
sequence_idx_{} {}
@@ -478,7 +478,8 @@
current_adjusted_allocation_ =
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
current_input_allocation_, target_framerate_fps_,
- DataRate::bps(current_input_allocation_.get_sum_bps() * 1.1)));
+ DataRate::BitsPerSec(current_input_allocation_.get_sum_bps() *
+ 1.1)));
ExpectNear(current_input_allocation_, current_adjusted_allocation_, 0.01);
}
}
@@ -520,7 +521,7 @@
current_adjusted_allocation_ =
adjuster_->AdjustRateAllocation(VideoEncoder::RateControlParameters(
current_input_allocation_, target_framerate_fps_,
- DataRate::bps(current_input_allocation_.get_sum_bps() * 2)));
+ DataRate::BitsPerSec(current_input_allocation_.get_sum_bps() * 2)));
ExpectNear(MultiplyAllocation(current_input_allocation_, 1 / 1.1),
current_adjusted_allocation_, 0.015);
}
diff --git a/video/encoder_overshoot_detector_unittest.cc b/video/encoder_overshoot_detector_unittest.cc
index 90528e4..a3c44eb 100644
--- a/video/encoder_overshoot_detector_unittest.cc
+++ b/video/encoder_overshoot_detector_unittest.cc
@@ -23,7 +23,7 @@
static constexpr double kDefaultFrameRateFps = 15;
EncoderOvershootDetectorTest()
: detector_(kWindowSizeMs),
- target_bitrate_(DataRate::bps(kDefaultBitrateBps)),
+ target_bitrate_(DataRate::BitsPerSec(kDefaultBitrateBps)),
target_framerate_fps_(kDefaultFrameRateFps) {}
protected:
@@ -111,7 +111,7 @@
RunConstantUtilizationTest(1.2, 1.2, 0.01, kWindowSizeMs);
target_framerate_fps_ /= 2;
RunConstantUtilizationTest(1.2, 1.2, 0.01, kWindowSizeMs / 2);
- target_bitrate_ = DataRate::bps(target_bitrate_.bps() / 2);
+ target_bitrate_ = DataRate::BitsPerSec(target_bitrate_.bps() / 2);
RunConstantUtilizationTest(1.2, 1.2, 0.01, kWindowSizeMs / 2);
}
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index eaeda96..34ad748 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -624,24 +624,25 @@
DataRate link_allocation = DataRate::Zero();
if (encoder_target_rate_bps_ > protection_bitrate_bps) {
link_allocation =
- DataRate::bps(encoder_target_rate_bps_ - protection_bitrate_bps);
+ DataRate::BitsPerSec(encoder_target_rate_bps_ - protection_bitrate_bps);
}
DataRate overhead =
- update.target_bitrate - DataRate::bps(encoder_target_rate_bps_);
+ update.target_bitrate - DataRate::BitsPerSec(encoder_target_rate_bps_);
DataRate encoder_stable_target_rate = update.stable_target_bitrate;
if (encoder_stable_target_rate > overhead) {
encoder_stable_target_rate = encoder_stable_target_rate - overhead;
} else {
- encoder_stable_target_rate = DataRate::bps(encoder_target_rate_bps_);
+ encoder_stable_target_rate = DataRate::BitsPerSec(encoder_target_rate_bps_);
}
encoder_target_rate_bps_ =
std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps_);
- encoder_stable_target_rate = std::min(DataRate::bps(encoder_max_bitrate_bps_),
- encoder_stable_target_rate);
+ encoder_stable_target_rate =
+ std::min(DataRate::BitsPerSec(encoder_max_bitrate_bps_),
+ encoder_stable_target_rate);
- DataRate encoder_target_rate = DataRate::bps(encoder_target_rate_bps_);
+ DataRate encoder_target_rate = DataRate::BitsPerSec(encoder_target_rate_bps_);
link_allocation = std::max(encoder_target_rate, link_allocation);
video_stream_encoder_->OnBitrateUpdated(
encoder_target_rate, encoder_stable_target_rate, link_allocation,
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 5c85453..2b5a90a 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -88,7 +88,7 @@
BitrateAllocationUpdate CreateAllocation(int bitrate_bps) {
BitrateAllocationUpdate update;
- update.target_bitrate = DataRate::bps(bitrate_bps);
+ update.target_bitrate = DataRate::BitsPerSec(bitrate_bps);
update.packet_loss_ratio = 0;
update.round_trip_time = TimeDelta::Zero();
return update;
@@ -695,7 +695,7 @@
min_transmit_bitrate_bps);
const DataRate network_constrained_rate =
- DataRate::bps(qvga_stream.target_bitrate_bps);
+ DataRate::BitsPerSec(qvga_stream.target_bitrate_bps);
BitrateAllocationUpdate update;
update.target_bitrate = network_constrained_rate;
update.stable_target_bitrate = network_constrained_rate;
@@ -713,8 +713,8 @@
// Test allocation where the link allocation is larger than the target,
// meaning we have some headroom on the link.
const DataRate qvga_max_bitrate =
- DataRate::bps(qvga_stream.max_bitrate_bps);
- const DataRate headroom = DataRate::bps(50000);
+ DataRate::BitsPerSec(qvga_stream.max_bitrate_bps);
+ const DataRate headroom = DataRate::BitsPerSec(50000);
const DataRate rate_with_headroom = qvga_max_bitrate + headroom;
update.target_bitrate = rate_with_headroom;
update.stable_target_bitrate = rate_with_headroom;
@@ -737,7 +737,7 @@
EXPECT_CALL(rtp_video_sender_, GetPayloadBitrateBps())
.WillOnce(Return(rate_with_headroom.bps()));
const DataRate headroom_minus_protection =
- rate_with_headroom - DataRate::bps(protection_bitrate_bps);
+ rate_with_headroom - DataRate::BitsPerSec(protection_bitrate_bps);
EXPECT_CALL(video_stream_encoder_,
OnBitrateUpdated(qvga_max_bitrate, qvga_max_bitrate,
headroom_minus_protection, 0, _, 0));
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 5a06499..b5ad286 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -388,7 +388,7 @@
start_bitrate_bps != 0 ? absl::optional<uint32_t>(start_bitrate_bps)
: absl::nullopt;
resource_adaptation_module_->SetStartBitrate(
- DataRate::bps(start_bitrate_bps));
+ DataRate::BitsPerSec(start_bitrate_bps));
});
}
@@ -934,9 +934,10 @@
// target in order to sustain the min bitrate of the video codec. In this
// case, make sure the bandwidth allocation is at least equal the allocation
// as that is part of the document contract for that field.
- new_rate_settings.rate_control.bandwidth_allocation = std::max(
- new_rate_settings.rate_control.bandwidth_allocation,
- DataRate::bps(new_rate_settings.rate_control.bitrate.get_sum_bps()));
+ new_rate_settings.rate_control.bandwidth_allocation =
+ std::max(new_rate_settings.rate_control.bandwidth_allocation,
+ DataRate::BitsPerSec(
+ new_rate_settings.rate_control.bitrate.get_sum_bps()));
if (bitrate_adjuster_) {
VideoBitrateAllocation adjusted_allocation =
@@ -1459,7 +1460,7 @@
// We are only interested in propagating the meta-data about the image, not
// encoded data itself, to the post encode function. Since we cannot be sure
// the pointer will still be valid when run on the task queue, set it to null.
- DataSize frame_size = DataSize::bytes(image_copy.size());
+ DataSize frame_size = DataSize::Bytes(image_copy.size());
image_copy.ClearEncodedData();
int temporal_index = 0;
@@ -1727,8 +1728,8 @@
bool VideoStreamEncoder::EncoderSwitchExperiment::IsBitrateBelowThreshold(
const DataRate& target_bitrate) {
- DataRate rate =
- DataRate::kbps(bitrate_filter.Apply(1.0, target_bitrate.kbps()));
+ DataRate rate = DataRate::KilobitsPerSec(
+ bitrate_filter.Apply(1.0, target_bitrate.kbps()));
return current_thresholds.bitrate && rate < *current_thresholds.bitrate;
}
@@ -1794,7 +1795,8 @@
rtc::FromString(thresholds_split[2], &pixel_count);
if (bitrate_kbps > 0) {
- result.codec_thresholds[codec].bitrate = DataRate::kbps(bitrate_kbps);
+ result.codec_thresholds[codec].bitrate =
+ DataRate::KilobitsPerSec(bitrate_kbps);
}
if (pixel_count > 0) {
diff --git a/video/video_stream_encoder_unittest.cc b/video/video_stream_encoder_unittest.cc
index 44a1419..a307e4a3 100644
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@@ -558,8 +558,9 @@
EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
.Times(1);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(
CreateFrame(1, codec_width_, codec_height_));
@@ -1168,8 +1169,9 @@
TEST_F(VideoStreamEncoderTest, EncodeOneFrame) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
rtc::Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
WaitForEncodedFrame(1);
@@ -1188,8 +1190,9 @@
EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// The pending frame should be received.
WaitForEncodedFrame(2);
@@ -1201,13 +1204,15 @@
TEST_F(VideoStreamEncoderTest, DropsFramesWhenRateSetToZero) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
- video_stream_encoder_->OnBitrateUpdated(DataRate::bps(0), DataRate::bps(0),
- DataRate::bps(0), 0, 0, 0);
+ video_stream_encoder_->OnBitrateUpdated(DataRate::BitsPerSec(0),
+ DataRate::BitsPerSec(0),
+ DataRate::BitsPerSec(0), 0, 0, 0);
// The encoder will cache up to one frame for a short duration. Adding two
// frames means that the first frame will be dropped and the second frame will
// be sent when the encoder is resumed.
@@ -1215,8 +1220,9 @@
video_source_.IncomingCapturedFrame(CreateFrame(3, nullptr));
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
WaitForEncodedFrame(3);
video_source_.IncomingCapturedFrame(CreateFrame(4, nullptr));
WaitForEncodedFrame(4);
@@ -1225,8 +1231,9 @@
TEST_F(VideoStreamEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
@@ -1240,8 +1247,9 @@
TEST_F(VideoStreamEncoderTest, DropsFrameAfterStop) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
@@ -1255,8 +1263,9 @@
TEST_F(VideoStreamEncoderTest, DropsPendingFramesOnSlowEncode) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
fake_encoder_.BlockNextEncode();
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
@@ -1273,8 +1282,9 @@
TEST_F(VideoStreamEncoderTest, DropFrameWithFailedI420Conversion) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
rtc::Event frame_destroyed_event;
video_source_.IncomingCapturedFrame(
@@ -1294,8 +1304,9 @@
// Capture a frame at codec_width_/codec_height_.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
// The encoder will have been configured once.
@@ -1315,14 +1326,16 @@
TEST_F(VideoStreamEncoderTest, DropsFramesWhenCongestionWindowPushbackSet) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
WaitForEncodedFrame(1);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0.5);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0.5);
// The congestion window pushback is set to 0.5, which will drop 1/2 of
// frames. Adding two frames means that the first frame will be dropped and
// the second frame will be sent to the encoder.
@@ -1339,8 +1352,9 @@
TEST_F(VideoStreamEncoderTest,
ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
EXPECT_EQ(0, sink_.number_of_reconfigurations());
// Capture a frame and wait for it to synchronize with the encoder thread.
@@ -1367,8 +1381,9 @@
TEST_F(VideoStreamEncoderTest, FrameResolutionChangeReconfigureEncoder) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Capture a frame and wait for it to synchronize with the encoder thread.
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
@@ -1394,8 +1409,9 @@
TEST_F(VideoStreamEncoderTest,
EncoderInstanceDestroyedBeforeAnotherInstanceCreated) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Capture a frame and wait for it to synchronize with the encoder thread.
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
@@ -1417,8 +1433,9 @@
TEST_F(VideoStreamEncoderTest, BitrateLimitsChangeReconfigureRateAllocator) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
@@ -1463,8 +1480,9 @@
TEST_F(VideoStreamEncoderTest,
IntersectionOfEncoderAndAppBitrateLimitsUsedWhenBothProvided) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const uint32_t kMinEncBitrateKbps = 100;
const uint32_t kMaxEncBitrateKbps = 1000;
@@ -1510,8 +1528,9 @@
TEST_F(VideoStreamEncoderTest,
EncoderAndAppLimitsDontIntersectEncoderLimitsIgnored) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const uint32_t kMinAppBitrateKbps = 100;
const uint32_t kMaxAppBitrateKbps = 200;
@@ -1545,8 +1564,9 @@
TEST_F(VideoStreamEncoderTest,
EncoderRecommendedMaxAndMinBitratesUsedForGivenResolution) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const VideoEncoder::ResolutionBitrateLimits encoder_bitrate_limits_270p(
480 * 270, 34 * 1000, 12 * 1000, 1234 * 1000);
@@ -1614,8 +1634,9 @@
TEST_F(VideoStreamEncoderTest, EncoderRecommendedMaxBitrateCapsTargetBitrate) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
@@ -1679,8 +1700,9 @@
video_source_.set_adaptation_enabled(true);
fake_encoder_.SetRequestedResolutionAlignment(kRequestedResolutionAlignment);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// On the 1st frame, we should have initialized the encoder and
// asked for its resolution requirements.
@@ -1712,8 +1734,9 @@
// Enable BALANCED preference, no initial limitation.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->SetSource(&video_source_,
webrtc::DegradationPreference::BALANCED);
VerifyNoLimitation(video_source_.sink_wants());
@@ -1797,8 +1820,9 @@
TEST_F(VideoStreamEncoderTest, SinkWantsStoredByDegradationPreference) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
VerifyNoLimitation(video_source_.sink_wants());
const int kFrameWidth = 1280;
@@ -1910,8 +1934,9 @@
TEST_F(VideoStreamEncoderTest, StatsTracksQualityAdaptationStats) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -1945,8 +1970,9 @@
TEST_F(VideoStreamEncoderTest, StatsTracksCpuAdaptationStats) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -1980,8 +2006,9 @@
TEST_F(VideoStreamEncoderTest, SwitchingSourceKeepsCpuAdaptation) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -2050,8 +2077,9 @@
TEST_F(VideoStreamEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -2112,8 +2140,9 @@
TEST_F(VideoStreamEncoderTest,
QualityAdaptationStatsAreResetWhenScalerIsDisabled) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -2169,8 +2198,9 @@
TEST_F(VideoStreamEncoderTest,
StatsTracksCpuAdaptationStatsWhenSwitchingSource) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 1280;
const int kHeight = 720;
@@ -2307,8 +2337,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Expect no scaling to begin with.
VerifyNoLimitation(video_source_.sink_wants());
@@ -2357,8 +2388,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
test::FrameForwarder source;
@@ -2391,8 +2423,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
test::FrameForwarder source;
@@ -2433,8 +2466,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
test::FrameForwarder source;
@@ -2461,8 +2495,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_RESOLUTION preference, no initial limitation.
test::FrameForwarder source;
@@ -2488,8 +2523,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
test::FrameForwarder source;
@@ -2517,8 +2553,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable DISABLED preference, no initial limitation.
test::FrameForwarder source;
@@ -2547,8 +2584,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -2586,8 +2624,9 @@
const int kHeight = 720;
const int kInputFps = 30;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
VideoSendStream::Stats stats = stats_proxy_->GetStats();
stats.input_frame_rate = kInputFps;
@@ -2633,8 +2672,9 @@
const size_t kNumFrames = 10;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable adapter, expected input resolutions when downscaling:
// 1280x720 -> 960x540 -> 640x360 -> 480x270 -> 320x180 (kMinPixelsPerFrame)
@@ -2670,8 +2710,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -2730,8 +2771,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -2790,9 +2832,10 @@
{kEncoderBitrateLimits540p, kEncoderBitrateLimits720p});
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps), 0, 0, 0);
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps), 0,
+ 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -2807,9 +2850,10 @@
// Reduce bitrate and trigger adapt down.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps), 0, 0, 0);
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps), 0,
+ 0, 0);
video_stream_encoder_->TriggerQualityLow();
// Insert 720p frame. It should be downscaled and encoded.
@@ -2824,9 +2868,10 @@
// Increase bitrate.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits720p.min_start_bitrate_bps), 0, 0, 0);
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits720p.min_start_bitrate_bps), 0,
+ 0, 0);
// Trigger adapt up. Higher resolution should be requested.
video_stream_encoder_->TriggerQualityHigh();
@@ -2841,9 +2886,10 @@
// Set bitrate equal to min bitrate of 540p.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps),
- DataRate::bps(kEncoderBitrateLimits540p.min_start_bitrate_bps), 0, 0, 0);
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps),
+ DataRate::BitsPerSec(kEncoderBitrateLimits540p.min_start_bitrate_bps), 0,
+ 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -2880,8 +2926,8 @@
void OnBitrateUpdated(int bitrate_bps) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(bitrate_bps), DataRate::bps(bitrate_bps),
- DataRate::bps(bitrate_bps), 0, 0, 0);
+ DataRate::BitsPerSec(bitrate_bps), DataRate::BitsPerSec(bitrate_bps),
+ DataRate::BitsPerSec(bitrate_bps), 0, 0, 0);
}
void InsertFrame() {
@@ -3166,8 +3212,9 @@
const int kWidth = 1280;
const int kHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -3305,8 +3352,9 @@
const int kHeight = 360;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
for (int i = 1; i <= SendStatisticsProxy::kMinRequiredMetricsSamples; ++i) {
video_source_.IncomingCapturedFrame(CreateFrame(i, kWidth, kHeight));
@@ -3333,8 +3381,9 @@
TEST_F(VideoStreamEncoderTest,
CpuLimitedHistogramIsNotReportedForDisabledDegradation) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kWidth = 640;
const int kHeight = 360;
@@ -3367,8 +3416,9 @@
EXPECT_CALL(bitrate_observer, OnBitrateAllocationUpdated(expected_bitrate))
.Times(1);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kLowTargetBitrateBps), DataRate::bps(kLowTargetBitrateBps),
- DataRate::bps(kLowTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(
CreateFrame(rtc::TimeMillis(), codec_width_, codec_height_));
@@ -3475,8 +3525,9 @@
const int kFramerate = 24;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
test::FrameForwarder source;
video_stream_encoder_->SetSource(
&source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
@@ -3537,8 +3588,9 @@
const int kHighFramerate = 25;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
test::FrameForwarder source;
video_stream_encoder_->SetSource(
&source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
@@ -3602,8 +3654,9 @@
const int kFramerate = 24;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
test::FrameForwarder source;
video_stream_encoder_->SetSource(
&source, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
@@ -3649,9 +3702,9 @@
TEST_F(VideoStreamEncoderTest, DropsFramesAndScalesWhenBitrateIsTooLow) {
const int kTooLowBitrateForFrameSizeBps = 10000;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
const int kWidth = 640;
const int kHeight = 360;
@@ -3681,9 +3734,9 @@
NumberOfDroppedFramesLimitedWhenBitrateIsTooLow) {
const int kTooLowBitrateForFrameSizeBps = 10000;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
const int kWidth = 640;
const int kHeight = 360;
@@ -3708,8 +3761,9 @@
const int kWidth = 640;
const int kHeight = 360;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kLowTargetBitrateBps), DataRate::bps(kLowTargetBitrateBps),
- DataRate::bps(kLowTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps), 0, 0, 0);
// Set degradation preference.
video_stream_encoder_->SetSource(
@@ -3734,8 +3788,9 @@
video_stream_encoder_->ConfigureEncoder(std::move(video_encoder_config),
kMaxPayloadLength);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kLowTargetBitrateBps), DataRate::bps(kLowTargetBitrateBps),
- DataRate::bps(kLowTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps),
+ DataRate::BitsPerSec(kLowTargetBitrateBps), 0, 0, 0);
// Force quality scaler reconfiguration by resetting the source.
video_stream_encoder_->SetSource(&video_source_,
@@ -3761,24 +3816,25 @@
const int kHeight = 360;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(1, kWidth, kHeight));
// Frame should not be dropped.
WaitForEncodedFrame(1);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kNotTooLowBitrateForFrameSizeBps),
- DataRate::bps(kNotTooLowBitrateForFrameSizeBps),
- DataRate::bps(kNotTooLowBitrateForFrameSizeBps), 0, 0, 0);
+ DataRate::BitsPerSec(kNotTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kNotTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kNotTooLowBitrateForFrameSizeBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(2, kWidth, kHeight));
// Frame should not be dropped.
WaitForEncodedFrame(2);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps),
- DataRate::bps(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps),
+ DataRate::BitsPerSec(kTooLowBitrateForFrameSizeBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(CreateFrame(3, kWidth, kHeight));
// Expect to drop this frame, the wait should time out.
ExpectDroppedFrame();
@@ -3806,9 +3862,10 @@
// Start at low bitrate.
const int kLowBitrateBps = 200000;
- video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kLowBitrateBps), DataRate::bps(kLowBitrateBps),
- DataRate::bps(kLowBitrateBps), 0, 0, 0);
+ video_stream_encoder_->OnBitrateUpdated(DataRate::BitsPerSec(kLowBitrateBps),
+ DataRate::BitsPerSec(kLowBitrateBps),
+ DataRate::BitsPerSec(kLowBitrateBps),
+ 0, 0, 0);
// Expect first frame to be dropped and resolution to be limited.
const int kWidth = 1280;
@@ -3820,10 +3877,10 @@
EXPECT_LT(source.sink_wants().max_pixel_count, kWidth * kHeight);
// Increase bitrate to encoder max.
- video_stream_encoder_->OnBitrateUpdated(DataRate::bps(config.max_bitrate_bps),
- DataRate::bps(config.max_bitrate_bps),
- DataRate::bps(config.max_bitrate_bps),
- 0, 0, 0);
+ video_stream_encoder_->OnBitrateUpdated(
+ DataRate::BitsPerSec(config.max_bitrate_bps),
+ DataRate::BitsPerSec(config.max_bitrate_bps),
+ DataRate::BitsPerSec(config.max_bitrate_bps), 0, 0, 0);
// Insert frames and advance |min_duration_ms|.
for (size_t i = 1; i <= 10; i++) {
@@ -3856,8 +3913,9 @@
const int kTooSmallWidth = 10;
const int kTooSmallHeight = 10;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable MAINTAIN_FRAMERATE preference, no initial limitation.
test::FrameForwarder source;
@@ -3883,8 +3941,9 @@
const int kTooSmallHeight = 10;
const int kFpsLimit = 7;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
test::FrameForwarder source;
@@ -3918,8 +3977,9 @@
TEST_F(VideoStreamEncoderTest, FailingInitEncodeDoesntCauseCrash) {
fake_encoder_.ForceInitEncodeFailure(true);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
ResetEncoder("VP8", 2, 1, 1, false);
const int kFrameWidth = 1280;
const int kFrameHeight = 720;
@@ -3933,8 +3993,9 @@
TEST_F(VideoStreamEncoderTest,
AdaptsResolutionOnOveruse_MaintainFramerateMode) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
const int kFrameWidth = 1280;
const int kFrameHeight = 720;
@@ -3968,8 +4029,9 @@
const int kFrameHeight = 720;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->SetSource(
&video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
video_source_.set_adaptation_enabled(true);
@@ -4071,8 +4133,9 @@
ResetEncoder("VP8", 1, 2, 1, true);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->SetSource(
&video_source_, webrtc::DegradationPreference::MAINTAIN_RESOLUTION);
video_source_.set_adaptation_enabled(true);
@@ -4111,8 +4174,9 @@
const int64_t kFrameIntervalMs = 150;
int64_t timestamp_ms = kFrameIntervalMs;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -4293,8 +4357,9 @@
const int64_t kFrameIntervalMs = 150;
int64_t timestamp_ms = kFrameIntervalMs;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -4408,8 +4473,9 @@
const int64_t kFrameIntervalMs = 150;
int64_t timestamp_ms = kFrameIntervalMs;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Enable BALANCED preference, no initial limitation.
AdaptingFrameForwarder source;
@@ -4498,8 +4564,9 @@
const int kFramerate = 24;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Trigger reconfigure encoder (without resetting the entire instance).
VideoEncoderConfig video_encoder_config;
video_encoder_config.codec_type = kVideoCodecVP8;
@@ -4533,8 +4600,9 @@
const int kHighFps = 30;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
max_framerate_ = kLowFps;
@@ -4549,8 +4617,9 @@
// Make sure encoder is updated with new target.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(
CreateFrame(timestamp_ms, kFrameWidth, kFrameHeight));
WaitForEncodedFrame(timestamp_ms);
@@ -4588,8 +4657,9 @@
MockBitrateObserver bitrate_observer;
video_stream_encoder_->SetBitrateAllocationObserver(&bitrate_observer);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->WaitUntilTaskQueueIsIdle();
// Insert a first video frame, causes another bitrate update.
@@ -4600,8 +4670,9 @@
WaitForEncodedFrame(timestamp_ms);
// Next, simulate video suspension due to pacer queue overrun.
- video_stream_encoder_->OnBitrateUpdated(DataRate::bps(0), DataRate::bps(0),
- DataRate::bps(0), 0, 1, 0);
+ video_stream_encoder_->OnBitrateUpdated(DataRate::BitsPerSec(0),
+ DataRate::BitsPerSec(0),
+ DataRate::BitsPerSec(0), 0, 1, 0);
// Skip ahead until a new periodic parameter update should have occured.
timestamp_ms += kProcessIntervalMs;
@@ -4622,8 +4693,9 @@
const int kFrameHeight = 720;
const CpuOveruseOptions default_options;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(
CreateFrame(1, kFrameWidth, kFrameHeight));
WaitForEncodedFrame(1);
@@ -4646,8 +4718,9 @@
fake_encoder_.SetIsHardwareAccelerated(true);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_source_.IncomingCapturedFrame(
CreateFrame(1, kFrameWidth, kFrameHeight));
WaitForEncodedFrame(1);
@@ -4668,8 +4741,9 @@
const int kNumFramesInRun = kFps * 5; // Runs of five seconds.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
max_framerate_ = kFps;
@@ -4704,9 +4778,9 @@
}
fake_encoder_.SimulateOvershoot(overshoot_factor);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps + 1000),
- DataRate::bps(kTargetBitrateBps + 1000),
- DataRate::bps(kTargetBitrateBps + 1000), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps + 1000),
+ DataRate::BitsPerSec(kTargetBitrateBps + 1000),
+ DataRate::BitsPerSec(kTargetBitrateBps + 1000), 0, 0, 0);
num_dropped = 0;
for (int i = 0; i < kNumFramesInRun; ++i) {
video_source_.IncomingCapturedFrame(
@@ -4719,8 +4793,9 @@
}
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Target framerate should be still be near the expected target, despite
// the frame drops.
@@ -4743,8 +4818,9 @@
int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
max_framerate_ = kActualInputFps;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Insert 3 seconds of video, with an input fps lower than configured max.
for (int i = 0; i < kActualInputFps * 3; ++i) {
@@ -4763,8 +4839,9 @@
TEST_F(VideoStreamEncoderTest, AccumulatesUpdateRectOnDroppedFrames) {
VideoFrame::UpdateRect rect;
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
fake_encoder_.BlockNextEncode();
video_source_.IncomingCapturedFrame(
@@ -4808,8 +4885,9 @@
TEST_F(VideoStreamEncoderTest, SetsFrameTypes) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// First frame is always keyframe.
video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
@@ -4840,9 +4918,9 @@
// Setup simulcast with three streams.
ResetEncoder("VP8", 3, 1, 1, false);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kSimulcastTargetBitrateBps),
- DataRate::bps(kSimulcastTargetBitrateBps),
- DataRate::bps(kSimulcastTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kSimulcastTargetBitrateBps),
+ DataRate::BitsPerSec(kSimulcastTargetBitrateBps),
+ DataRate::BitsPerSec(kSimulcastTargetBitrateBps), 0, 0, 0);
// Wait for all three layers before triggering event.
sink_.SetNumExpectedLayers(3);
@@ -4883,8 +4961,9 @@
encoder_factory_.SetHasInternalSource(true);
ResetEncoder("VP8", 1, 1, 1, false);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Call encoder directly, simulating internal source where encoded frame
// callback in VideoStreamEncoder is called despite no OnFrame().
@@ -4921,8 +5000,9 @@
encoder_factory_.SetHasInternalSource(true);
ResetEncoder("VP8", 1, 1, 1, false);
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
int64_t timestamp = 1;
EncodedImage image;
@@ -5013,8 +5093,9 @@
const int kTargetBitrateBps = 300000; // To low for HD resolution.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->WaitUntilTaskQueueIsIdle();
// Insert a first video frame. It should be dropped because of downscale in
@@ -5053,9 +5134,9 @@
// Initial rate.
video_stream_encoder_->OnBitrateUpdated(
- /*target_bitrate=*/DataRate::kbps(300),
- /*stable_target_bitrate=*/DataRate::kbps(300),
- /*link_allocation=*/DataRate::kbps(300),
+ /*target_bitrate=*/DataRate::KilobitsPerSec(300),
+ /*stable_target_bitrate=*/DataRate::KilobitsPerSec(300),
+ /*link_allocation=*/DataRate::KilobitsPerSec(300),
/*fraction_lost=*/0,
/*rtt_ms=*/0,
/*cwnd_reduce_ratio=*/0);
@@ -5069,8 +5150,8 @@
// Set a target rate below the minimum allowed by the codec settings.
VideoCodec codec_config = fake_encoder_.codec_config();
- DataRate min_rate = DataRate::kbps(codec_config.minBitrate);
- DataRate target_rate = min_rate - DataRate::kbps(1);
+ DataRate min_rate = DataRate::KilobitsPerSec(codec_config.minBitrate);
+ DataRate target_rate = min_rate - DataRate::KilobitsPerSec(1);
video_stream_encoder_->OnBitrateUpdated(
/*target_bitrate=*/target_rate,
/*stable_target_bitrate=*/target_rate,
@@ -5083,7 +5164,8 @@
// Target bitrate and bandwidth allocation should both be capped at min_rate.
auto rate_settings = fake_encoder_.GetAndResetLastRateControlSettings();
ASSERT_TRUE(rate_settings.has_value());
- DataRate allocation_sum = DataRate::bps(rate_settings->bitrate.get_sum_bps());
+ DataRate allocation_sum =
+ DataRate::BitsPerSec(rate_settings->bitrate.get_sum_bps());
EXPECT_EQ(min_rate, allocation_sum);
EXPECT_EQ(rate_settings->bandwidth_allocation, min_rate);
@@ -5092,8 +5174,9 @@
TEST_F(VideoStreamEncoderTest, EncoderRatesPropagatedOnReconfigure) {
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
// Capture a frame and wait for it to synchronize with the encoder thread.
int64_t timestamp_ms = fake_clock_.TimeNanos() / rtc::kNumNanosecsPerMillisec;
video_source_.IncomingCapturedFrame(CreateFrame(timestamp_ms, nullptr));
@@ -5165,9 +5248,9 @@
Field(&Config::value, "pong")))));
video_stream_encoder_->OnBitrateUpdated(
- /*target_bitrate=*/DataRate::kbps(50),
- /*stable_target_bitrate=*/DataRate::kbps(kDontCare),
- /*link_allocation=*/DataRate::kbps(kDontCare),
+ /*target_bitrate=*/DataRate::KilobitsPerSec(50),
+ /*stable_target_bitrate=*/DataRate::KilobitsPerSec(kDontCare),
+ /*link_allocation=*/DataRate::KilobitsPerSec(kDontCare),
/*fraction_lost=*/0,
/*rtt_ms=*/0,
/*cwnd_reduce_ratio=*/0);
@@ -5197,9 +5280,10 @@
// setting some bitrate so that subsequent calls to WaitForEncodedFrame does
// not fail.
video_stream_encoder_->OnBitrateUpdated(
- /*target_bitrate=*/DataRate::kbps(kSufficientBitrateToNotDrop),
- /*stable_target_bitrate=*/DataRate::kbps(kSufficientBitrateToNotDrop),
- /*link_allocation=*/DataRate::kbps(kSufficientBitrateToNotDrop),
+ /*target_bitrate=*/DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
+ /*stable_target_bitrate=*/
+ DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
+ /*link_allocation=*/DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
/*fraction_lost=*/0,
/*rtt_ms=*/0,
/*cwnd_reduce_ratio=*/0);
@@ -5264,9 +5348,9 @@
Field(&SdpVideoFormat::name, "AV1"))));
video_stream_encoder_->OnBitrateUpdated(
- /*target_bitrate=*/DataRate::kbps(50),
- /*stable_target_bitrate=*/DataRate::kbps(kDontCare),
- /*link_allocation=*/DataRate::kbps(kDontCare),
+ /*target_bitrate=*/DataRate::KilobitsPerSec(50),
+ /*stable_target_bitrate=*/DataRate::KilobitsPerSec(kDontCare),
+ /*link_allocation=*/DataRate::KilobitsPerSec(kDontCare),
/*fraction_lost=*/0,
/*rtt_ms=*/0,
/*cwnd_reduce_ratio=*/0);
@@ -5294,9 +5378,10 @@
// setting some bitrate so that subsequent calls to WaitForEncodedFrame does
// not fail.
video_stream_encoder_->OnBitrateUpdated(
- /*target_bitrate=*/DataRate::kbps(kSufficientBitrateToNotDrop),
- /*stable_target_bitrate=*/DataRate::kbps(kSufficientBitrateToNotDrop),
- /*link_allocation=*/DataRate::kbps(kSufficientBitrateToNotDrop),
+ /*target_bitrate=*/DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
+ /*stable_target_bitrate=*/
+ DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
+ /*link_allocation=*/DataRate::KilobitsPerSec(kSufficientBitrateToNotDrop),
/*fraction_lost=*/0,
/*rtt_ms=*/0,
/*cwnd_reduce_ratio=*/0);
@@ -5332,7 +5417,7 @@
const int kFrameHeight = 180;
// Set initial rate.
- auto rate = DataRate::kbps(100);
+ auto rate = DataRate::KilobitsPerSec(100);
video_stream_encoder_->OnBitrateUpdated(
/*target_bitrate=*/rate,
/*stable_target_bitrate=*/rate,
@@ -5350,7 +5435,7 @@
EXPECT_EQ(1, fake_encoder_.GetNumSetRates());
// Change of target bitrate propagates to the encoder.
- auto new_stable_rate = rate - DataRate::kbps(5);
+ auto new_stable_rate = rate - DataRate::KilobitsPerSec(5);
video_stream_encoder_->OnBitrateUpdated(
/*target_bitrate=*/new_stable_rate,
/*stable_target_bitrate=*/new_stable_rate,
@@ -5369,7 +5454,7 @@
const int kFrameHeight = 180;
// Set initial rate.
- auto rate = DataRate::kbps(100);
+ auto rate = DataRate::KilobitsPerSec(100);
video_stream_encoder_->OnBitrateUpdated(
/*target_bitrate=*/rate,
/*stable_target_bitrate=*/rate,
@@ -5388,7 +5473,7 @@
// Set a higher target rate without changing the link_allocation. Should not
// reset encoder's rate.
- auto new_stable_rate = rate - DataRate::kbps(5);
+ auto new_stable_rate = rate - DataRate::KilobitsPerSec(5);
video_stream_encoder_->OnBitrateUpdated(
/*target_bitrate=*/rate,
/*stable_target_bitrate=*/new_stable_rate,
@@ -5417,8 +5502,9 @@
// BALANCED degradation preference is required for this feature.
video_stream_encoder_->OnBitrateUpdated(
- DataRate::bps(kTargetBitrateBps), DataRate::bps(kTargetBitrateBps),
- DataRate::bps(kTargetBitrateBps), 0, 0, 0);
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps),
+ DataRate::BitsPerSec(kTargetBitrateBps), 0, 0, 0);
video_stream_encoder_->SetSource(&video_source_,
webrtc::DegradationPreference::BALANCED);
VerifyNoLimitation(video_source_.sink_wants());
