Optional: Use nullopt and implicit construction in /modules/audio_coding
Changes places where we explicitly construct an Optional to instead use
nullopt or the requisite value type only.
This CL was uploaded by git cl split.
R=kwiberg@webrtc.org
Bug: None
Change-Id: I055411a3e521964c81100869a197dd92f5608f1b
Reviewed-on: https://webrtc-review.googlesource.com/23619
Commit-Queue: Oskar Sundbom <ossu@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20728}diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
index 54423e6..55e5309 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
@@ -58,68 +58,61 @@
AudioNetworkAdaptorImpl::~AudioNetworkAdaptorImpl() = default;
void AudioNetworkAdaptorImpl::SetUplinkBandwidth(int uplink_bandwidth_bps) {
- last_metrics_.uplink_bandwidth_bps = rtc::Optional<int>(uplink_bandwidth_bps);
+ last_metrics_.uplink_bandwidth_bps = uplink_bandwidth_bps;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
- network_metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(uplink_bandwidth_bps);
+ network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetUplinkPacketLossFraction(
float uplink_packet_loss_fraction) {
- last_metrics_.uplink_packet_loss_fraction =
- rtc::Optional<float>(uplink_packet_loss_fraction);
+ last_metrics_.uplink_packet_loss_fraction = uplink_packet_loss_fraction;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
- network_metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(uplink_packet_loss_fraction);
+ network_metrics.uplink_packet_loss_fraction = uplink_packet_loss_fraction;
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {
last_metrics_.uplink_recoverable_packet_loss_fraction =
- rtc::Optional<float>(uplink_recoverable_packet_loss_fraction);
+ uplink_recoverable_packet_loss_fraction;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
network_metrics.uplink_recoverable_packet_loss_fraction =
- rtc::Optional<float>(uplink_recoverable_packet_loss_fraction);
+ uplink_recoverable_packet_loss_fraction;
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetRtt(int rtt_ms) {
- last_metrics_.rtt_ms = rtc::Optional<int>(rtt_ms);
+ last_metrics_.rtt_ms = rtt_ms;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
- network_metrics.rtt_ms = rtc::Optional<int>(rtt_ms);
+ network_metrics.rtt_ms = rtt_ms;
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetTargetAudioBitrate(
int target_audio_bitrate_bps) {
- last_metrics_.target_audio_bitrate_bps =
- rtc::Optional<int>(target_audio_bitrate_bps);
+ last_metrics_.target_audio_bitrate_bps = target_audio_bitrate_bps;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
- network_metrics.target_audio_bitrate_bps =
- rtc::Optional<int>(target_audio_bitrate_bps);
+ network_metrics.target_audio_bitrate_bps = target_audio_bitrate_bps;
UpdateNetworkMetrics(network_metrics);
}
void AudioNetworkAdaptorImpl::SetOverhead(size_t overhead_bytes_per_packet) {
- last_metrics_.overhead_bytes_per_packet =
- rtc::Optional<size_t>(overhead_bytes_per_packet);
+ last_metrics_.overhead_bytes_per_packet = overhead_bytes_per_packet;
DumpNetworkMetrics();
Controller::NetworkMetrics network_metrics;
- network_metrics.overhead_bytes_per_packet =
- rtc::Optional<size_t>(overhead_bytes_per_packet);
+ network_metrics.overhead_bytes_per_packet = overhead_bytes_per_packet;
UpdateNetworkMetrics(network_metrics);
}
@@ -131,7 +124,7 @@
// Update ANA stats.
auto increment_opt = [](rtc::Optional<uint32_t>& a) {
- a = rtc::Optional<uint32_t>(a.value_or(0) + 1);
+ a = a.value_or(0) + 1;
};
if (prev_config_) {
if (config.bitrate_bps != prev_config_->bitrate_bps) {
@@ -154,11 +147,10 @@
increment_opt(stats_.channel_action_counter);
}
if (config.uplink_packet_loss_fraction) {
- stats_.uplink_packet_loss_fraction =
- rtc::Optional<float>(*config.uplink_packet_loss_fraction);
+ stats_.uplink_packet_loss_fraction = *config.uplink_packet_loss_fraction;
}
}
- prev_config_ = rtc::Optional<AudioEncoderRuntimeConfig>(config);
+ prev_config_ = config;
// Prevent certain controllers from taking action (determined by field trials)
if (!enable_bitrate_adaptation_ && config.bitrate_bps) {
diff --git a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
index 1f0f71a..c437918 100644
--- a/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
@@ -124,7 +124,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr int kBandwidth = 16000;
Controller::NetworkMetrics check;
- check.uplink_bandwidth_bps = rtc::Optional<int>(kBandwidth);
+ check.uplink_bandwidth_bps = kBandwidth;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetUplinkBandwidth(kBandwidth);
}
@@ -134,7 +134,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr float kPacketLoss = 0.7f;
Controller::NetworkMetrics check;
- check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
+ check.uplink_packet_loss_fraction = kPacketLoss;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
}
@@ -144,8 +144,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr float kRecoverablePacketLoss = 0.1f;
Controller::NetworkMetrics check;
- check.uplink_recoverable_packet_loss_fraction =
- rtc::Optional<float>(kRecoverablePacketLoss);
+ check.uplink_recoverable_packet_loss_fraction = kRecoverablePacketLoss;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
kRecoverablePacketLoss);
@@ -155,7 +154,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr int kRtt = 100;
Controller::NetworkMetrics check;
- check.rtt_ms = rtc::Optional<int>(kRtt);
+ check.rtt_ms = kRtt;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetRtt(kRtt);
}
@@ -165,7 +164,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr int kTargetAudioBitrate = 15000;
Controller::NetworkMetrics check;
- check.target_audio_bitrate_bps = rtc::Optional<int>(kTargetAudioBitrate);
+ check.target_audio_bitrate_bps = kTargetAudioBitrate;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate);
}
@@ -174,7 +173,7 @@
auto states = CreateAudioNetworkAdaptor();
constexpr size_t kOverhead = 64;
Controller::NetworkMetrics check;
- check.overhead_bytes_per_packet = rtc::Optional<size_t>(kOverhead);
+ check.overhead_bytes_per_packet = kOverhead;
SetExpectCallToUpdateNetworkMetrics(states.mock_controllers, check);
states.audio_network_adaptor->SetOverhead(kOverhead);
}
@@ -196,8 +195,8 @@
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(kClockInitialTimeMs));
auto states = CreateAudioNetworkAdaptor();
AudioEncoderRuntimeConfig config;
- config.bitrate_bps = rtc::Optional<int>(32000);
- config.enable_fec = rtc::Optional<bool>(true);
+ config.bitrate_bps = 32000;
+ config.enable_fec = true;
EXPECT_CALL(*states.mock_controllers[0], MakeDecision(_))
.WillOnce(SetArgPointee<0>(config));
@@ -223,7 +222,7 @@
constexpr size_t kOverhead = 64;
Controller::NetworkMetrics check;
- check.uplink_bandwidth_bps = rtc::Optional<int>(kBandwidth);
+ check.uplink_bandwidth_bps = kBandwidth;
int64_t timestamp_check = kClockInitialTimeMs;
EXPECT_CALL(*states.mock_debug_dump_writer,
@@ -232,15 +231,14 @@
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(100));
timestamp_check += 100;
- check.uplink_packet_loss_fraction = rtc::Optional<float>(kPacketLoss);
+ check.uplink_packet_loss_fraction = kPacketLoss;
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkPacketLossFraction(kPacketLoss);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
timestamp_check += 50;
- check.uplink_recoverable_packet_loss_fraction =
- rtc::Optional<float>(kRecoverablePacketLoss);
+ check.uplink_recoverable_packet_loss_fraction = kRecoverablePacketLoss;
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetUplinkRecoverablePacketLossFraction(
@@ -248,21 +246,21 @@
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
timestamp_check += 200;
- check.rtt_ms = rtc::Optional<int>(kRtt);
+ check.rtt_ms = kRtt;
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetRtt(kRtt);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(150));
timestamp_check += 150;
- check.target_audio_bitrate_bps = rtc::Optional<int>(kTargetAudioBitrate);
+ check.target_audio_bitrate_bps = kTargetAudioBitrate;
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetTargetAudioBitrate(kTargetAudioBitrate);
fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(50));
timestamp_check += 50;
- check.overhead_bytes_per_packet = rtc::Optional<size_t>(kOverhead);
+ check.overhead_bytes_per_packet = kOverhead;
EXPECT_CALL(*states.mock_debug_dump_writer,
DumpNetworkMetrics(NetworkMetricsIs(check), timestamp_check));
states.audio_network_adaptor->SetOverhead(kOverhead);
@@ -275,8 +273,8 @@
auto states = CreateAudioNetworkAdaptor();
AudioEncoderRuntimeConfig config;
- config.bitrate_bps = rtc::Optional<int>(32000);
- config.enable_fec = rtc::Optional<bool>(true);
+ config.bitrate_bps = 32000;
+ config.enable_fec = true;
EXPECT_CALL(*states.mock_controllers[0], MakeDecision(_))
.WillOnce(SetArgPointee<0>(config));
@@ -291,18 +289,18 @@
// Simulate some adaptation, otherwise the stats will not show anything.
AudioEncoderRuntimeConfig config1, config2;
- config1.bitrate_bps = rtc::Optional<int>(32000);
- config1.num_channels = rtc::Optional<size_t>(2);
- config1.enable_fec = rtc::Optional<bool>(true);
- config1.enable_dtx = rtc::Optional<bool>(true);
- config1.frame_length_ms = rtc::Optional<int>(120);
- config1.uplink_packet_loss_fraction = rtc::Optional<float>(0.1f);
- config2.bitrate_bps = rtc::Optional<int>(16000);
- config2.num_channels = rtc::Optional<size_t>(1);
- config2.enable_fec = rtc::Optional<bool>(false);
- config2.enable_dtx = rtc::Optional<bool>(false);
- config2.frame_length_ms = rtc::Optional<int>(60);
- config1.uplink_packet_loss_fraction = rtc::Optional<float>(0.1f);
+ config1.bitrate_bps = 32000;
+ config1.num_channels = 2;
+ config1.enable_fec = true;
+ config1.enable_dtx = true;
+ config1.frame_length_ms = 120;
+ config1.uplink_packet_loss_fraction = 0.1f;
+ config2.bitrate_bps = 16000;
+ config2.num_channels = 1;
+ config2.enable_fec = false;
+ config2.enable_dtx = false;
+ config2.frame_length_ms = 60;
+ config1.uplink_packet_loss_fraction = 0.1f;
EXPECT_CALL(*states.mock_controllers[0], MakeDecision(_))
.WillOnce(SetArgPointee<0>(config1));
diff --git a/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc b/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc
index 16c4bc4..6850926 100644
--- a/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc
+++ b/modules/audio_coding/audio_network_adaptor/bitrate_controller.cc
@@ -69,7 +69,7 @@
(*overhead_bytes_per_packet_ + offset) * 8 * 1000 / frame_length_ms_);
bitrate_bps_ = std::max(0, *target_audio_bitrate_bps_ - overhead_rate_bps);
}
- config->bitrate_bps = rtc::Optional<int>(bitrate_bps_);
+ config->bitrate_bps = bitrate_bps_;
}
} // namespace audio_network_adaptor
diff --git a/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc b/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
index 09d1066..daad293 100644
--- a/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
@@ -43,7 +43,7 @@
AudioEncoderRuntimeConfig config;
config.frame_length_ms = frame_length_ms;
controller->MakeDecision(&config);
- EXPECT_EQ(rtc::Optional<int>(expected_bitrate_bps), config.bitrate_bps);
+ EXPECT_EQ(expected_bitrate_bps, config.bitrate_bps);
}
} // namespace
@@ -58,10 +58,8 @@
constexpr size_t kOverheadBytesPerPacket = 64;
BitrateController controller(BitrateController::Config(
kInitialBitrateBps, kInitialFrameLengthMs, 0, 0));
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(kInitialFrameLengthMs * 2),
- kInitialBitrateBps);
+ UpdateNetworkMetrics(&controller, rtc::nullopt, kOverheadBytesPerPacket);
+ CheckDecision(&controller, kInitialFrameLengthMs * 2, kInitialBitrateBps);
}
TEST(AnaBitrateControllerTest, OutputInitValueWhenOverheadUnknown) {
@@ -70,10 +68,8 @@
constexpr int kTargetBitrateBps = 48000;
BitrateController controller(BitrateController::Config(
kInitialBitrateBps, kInitialFrameLengthMs, 0, 0));
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>());
- CheckDecision(&controller, rtc::Optional<int>(kInitialFrameLengthMs * 2),
- kInitialBitrateBps);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, rtc::nullopt);
+ CheckDecision(&controller, kInitialFrameLengthMs * 2, kInitialBitrateBps);
}
TEST(AnaBitrateControllerTest, ChangeBitrateOnTargetBitrateChanged) {
@@ -89,10 +85,8 @@
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
// Frame length unchanged, bitrate changes in accordance with
// |metrics.target_audio_bitrate_bps| and |metrics.overhead_bytes_per_packet|.
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(kInitialFrameLengthMs),
- kBitrateBps);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, kInitialFrameLengthMs, kBitrateBps);
}
TEST(AnaBitrateControllerTest, UpdateMultipleNetworkMetricsAtOnce) {
@@ -114,13 +108,10 @@
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
Controller::NetworkMetrics network_metrics;
- network_metrics.target_audio_bitrate_bps =
- rtc::Optional<int>(kTargetBitrateBps);
- network_metrics.overhead_bytes_per_packet =
- rtc::Optional<size_t>(kOverheadBytesPerPacket);
+ network_metrics.target_audio_bitrate_bps = kTargetBitrateBps;
+ network_metrics.overhead_bytes_per_packet = kOverheadBytesPerPacket;
controller.UpdateNetworkMetrics(network_metrics);
- CheckDecision(&controller, rtc::Optional<int>(kInitialFrameLengthMs),
- kBitrateBps);
+ CheckDecision(&controller, kInitialFrameLengthMs, kBitrateBps);
}
TEST(AnaBitrateControllerTest, TreatUnknownFrameLengthAsFrameLengthUnchanged) {
@@ -134,9 +125,8 @@
constexpr int kBitrateBps =
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(), kBitrateBps);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, rtc::nullopt, kBitrateBps);
}
TEST(AnaBitrateControllerTest, IncreaseBitrateOnFrameLengthIncreased) {
@@ -151,17 +141,15 @@
constexpr int kBitrateBps =
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(), kBitrateBps);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, rtc::nullopt, kBitrateBps);
constexpr int kFrameLengthMs = 60;
constexpr size_t kPacketOverheadRateDiff =
kOverheadBytesPerPacket * 8 * 1000 / 20 -
kOverheadBytesPerPacket * 8 * 1000 / 60;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(kFrameLengthMs),
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, kFrameLengthMs,
kBitrateBps + kPacketOverheadRateDiff);
}
@@ -177,17 +165,15 @@
constexpr int kBitrateBps =
kTargetBitrateBps -
kOverheadBytesPerPacket * 8 * 1000 / kInitialFrameLengthMs;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(), kBitrateBps);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, rtc::nullopt, kBitrateBps);
constexpr int kFrameLengthMs = 20;
constexpr size_t kPacketOverheadRateDiff =
kOverheadBytesPerPacket * 8 * 1000 / 20 -
kOverheadBytesPerPacket * 8 * 1000 / 60;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(kFrameLengthMs),
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, kFrameLengthMs,
kBitrateBps - kPacketOverheadRateDiff);
}
@@ -200,9 +186,8 @@
// Set a target rate smaller than overhead rate, the bitrate is bounded by 0.
constexpr int kTargetBitrateBps =
kOverheadBytesPerPacket * 8 * 1000 / kFrameLengthMs - 1;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(kTargetBitrateBps),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
- CheckDecision(&controller, rtc::Optional<int>(kFrameLengthMs), 0);
+ UpdateNetworkMetrics(&controller, kTargetBitrateBps, kOverheadBytesPerPacket);
+ CheckDecision(&controller, kFrameLengthMs, 0);
}
TEST(AnaBitrateControllerTest, CheckBehaviorOnChangingCondition) {
@@ -217,46 +202,36 @@
int current_bitrate = rtc::checked_cast<int>(
overall_bitrate - overhead_bytes_per_packet * 8 * 1000 / frame_length_ms);
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
// Next: increase overall bitrate.
overall_bitrate += 100;
current_bitrate += 100;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
// Next: change frame length.
frame_length_ms = 60;
current_bitrate += rtc::checked_cast<int>(
overhead_bytes_per_packet * 8 * 1000 / 20 -
overhead_bytes_per_packet * 8 * 1000 / 60);
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
// Next: change overhead.
overhead_bytes_per_packet -= 30;
current_bitrate += 30 * 8 * 1000 / frame_length_ms;
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
// Next: change frame length.
frame_length_ms = 20;
current_bitrate -= rtc::checked_cast<int>(
overhead_bytes_per_packet * 8 * 1000 / 20 -
overhead_bytes_per_packet * 8 * 1000 / 60);
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
// Next: decrease overall bitrate and frame length.
overall_bitrate -= 100;
@@ -266,10 +241,8 @@
overhead_bytes_per_packet * 8 * 1000 / 20 -
overhead_bytes_per_packet * 8 * 1000 / 60);
- UpdateNetworkMetrics(&controller, rtc::Optional<int>(overall_bitrate),
- rtc::Optional<size_t>(overhead_bytes_per_packet));
- CheckDecision(&controller, rtc::Optional<int>(frame_length_ms),
- current_bitrate);
+ UpdateNetworkMetrics(&controller, overall_bitrate, overhead_bytes_per_packet);
+ CheckDecision(&controller, frame_length_ms, current_bitrate);
}
} // namespace audio_network_adaptor
diff --git a/modules/audio_coding/audio_network_adaptor/channel_controller.cc b/modules/audio_coding/audio_network_adaptor/channel_controller.cc
index 55a913a..a1c30db 100644
--- a/modules/audio_coding/audio_network_adaptor/channel_controller.cc
+++ b/modules/audio_coding/audio_network_adaptor/channel_controller.cc
@@ -55,7 +55,7 @@
std::min(static_cast<size_t>(2), config_.num_encoder_channels);
}
}
- config->num_channels = rtc::Optional<size_t>(channels_to_encode_);
+ config->num_channels = channels_to_encode_;
}
} // namespace webrtc
diff --git a/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc b/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
index 73160fe..64e5dae 100644
--- a/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
@@ -41,7 +41,7 @@
}
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
- EXPECT_EQ(rtc::Optional<size_t>(expected_num_channels), config.num_channels);
+ EXPECT_EQ(expected_num_channels, config.num_channels);
}
} // namespace
@@ -49,37 +49,35 @@
TEST(ChannelControllerTest, OutputInitValueWhenUplinkBandwidthUnknown) {
constexpr int kInitChannels = 2;
auto controller = CreateChannelController(kInitChannels);
- CheckDecision(controller.get(), rtc::Optional<int>(), kInitChannels);
+ CheckDecision(controller.get(), rtc::nullopt, kInitChannels);
}
TEST(ChannelControllerTest, SwitchTo2ChannelsOnHighUplinkBandwidth) {
constexpr int kInitChannels = 1;
auto controller = CreateChannelController(kInitChannels);
// Use high bandwidth to check output switch to 2.
- CheckDecision(controller.get(), rtc::Optional<int>(kChannel1To2BandwidthBps),
- 2);
+ CheckDecision(controller.get(), kChannel1To2BandwidthBps, 2);
}
TEST(ChannelControllerTest, SwitchTo1ChannelOnLowUplinkBandwidth) {
constexpr int kInitChannels = 2;
auto controller = CreateChannelController(kInitChannels);
// Use low bandwidth to check output switch to 1.
- CheckDecision(controller.get(), rtc::Optional<int>(kChannel2To1BandwidthBps),
- 1);
+ CheckDecision(controller.get(), kChannel2To1BandwidthBps, 1);
}
TEST(ChannelControllerTest, Maintain1ChannelOnMediumUplinkBandwidth) {
constexpr int kInitChannels = 1;
auto controller = CreateChannelController(kInitChannels);
// Use between-thresholds bandwidth to check output remains at 1.
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps), 1);
+ CheckDecision(controller.get(), kMediumBandwidthBps, 1);
}
TEST(ChannelControllerTest, Maintain2ChannelsOnMediumUplinkBandwidth) {
constexpr int kInitChannels = 2;
auto controller = CreateChannelController(kInitChannels);
// Use between-thresholds bandwidth to check output remains at 2.
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps), 2);
+ CheckDecision(controller.get(), kMediumBandwidthBps, 2);
}
TEST(ChannelControllerTest, CheckBehaviorOnChangingUplinkBandwidth) {
@@ -87,18 +85,16 @@
auto controller = CreateChannelController(kInitChannels);
// Use between-thresholds bandwidth to check output remains at 1.
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps), 1);
+ CheckDecision(controller.get(), kMediumBandwidthBps, 1);
// Use high bandwidth to check output switch to 2.
- CheckDecision(controller.get(), rtc::Optional<int>(kChannel1To2BandwidthBps),
- 2);
+ CheckDecision(controller.get(), kChannel1To2BandwidthBps, 2);
// Use between-thresholds bandwidth to check output remains at 2.
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps), 2);
+ CheckDecision(controller.get(), kMediumBandwidthBps, 2);
// Use low bandwidth to check output switch to 1.
- CheckDecision(controller.get(), rtc::Optional<int>(kChannel2To1BandwidthBps),
- 1);
+ CheckDecision(controller.get(), kChannel2To1BandwidthBps, 1);
}
} // namespace webrtc
diff --git a/modules/audio_coding/audio_network_adaptor/controller_manager.cc b/modules/audio_coding/audio_network_adaptor/controller_manager.cc
index d573960..313aa62 100644
--- a/modules/audio_coding/audio_network_adaptor/controller_manager.cc
+++ b/modules/audio_coding/audio_network_adaptor/controller_manager.cc
@@ -327,7 +327,7 @@
const std::map<const Controller*, std::pair<int, float>>& scoring_points)
: config_(config),
controllers_(std::move(controllers)),
- last_reordering_time_ms_(rtc::Optional<int64_t>()),
+ last_reordering_time_ms_(rtc::nullopt),
last_scoring_point_(0, 0.0) {
for (auto& controller : controllers_)
default_sorted_controllers_.push_back(controller.get());
@@ -389,7 +389,7 @@
if (sorted_controllers_ != sorted_controllers) {
sorted_controllers_ = sorted_controllers;
- last_reordering_time_ms_ = rtc::Optional<int64_t>(now_ms);
+ last_reordering_time_ms_ = now_ms;
last_scoring_point_ = scoring_point;
}
return sorted_controllers_;
diff --git a/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc b/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
index 846397a..576661c 100644
--- a/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
@@ -124,41 +124,38 @@
auto states = CreateControllerManager();
// |network_metrics| are empty, and the controllers are supposed to follow the
// default order.
- CheckControllersOrder(&states, rtc::Optional<int>(), rtc::Optional<float>(),
+ CheckControllersOrder(&states, rtc::nullopt, rtc::nullopt,
{0, 1, 2, 3});
}
TEST(ControllerManagerTest, ControllersWithoutCharPointAtEndAndInDefaultOrder) {
auto states = CreateControllerManager();
- CheckControllersOrder(&states, rtc::Optional<int>(0),
- rtc::Optional<float>(0.0),
+ CheckControllersOrder(&states, 0,
+ 0.0,
{kNumControllers - 2, kNumControllers - 1, -1, -1});
}
TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) {
auto states = CreateControllerManager();
- CheckControllersOrder(
- &states, rtc::Optional<int>(kChracteristicBandwithBps[1]),
- rtc::Optional<float>(kChracteristicPacketLossFraction[1]),
- {kNumControllers - 2, kNumControllers - 1, 1, 0});
+ CheckControllersOrder(&states, kChracteristicBandwithBps[1],
+ kChracteristicPacketLossFraction[1],
+ {kNumControllers - 2, kNumControllers - 1, 1, 0});
}
TEST(ControllerManagerTest, DoNotReorderBeforeMinReordingTime) {
rtc::ScopedFakeClock fake_clock;
auto states = CreateControllerManager();
- CheckControllersOrder(
- &states, rtc::Optional<int>(kChracteristicBandwithBps[0]),
- rtc::Optional<float>(kChracteristicPacketLossFraction[0]),
- {kNumControllers - 2, kNumControllers - 1, 0, 1});
+ CheckControllersOrder(&states, kChracteristicBandwithBps[0],
+ kChracteristicPacketLossFraction[0],
+ {kNumControllers - 2, kNumControllers - 1, 0, 1});
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
// Move uplink bandwidth and packet loss fraction to the other controller's
// characteristic point, which would cause controller manager to reorder the
// controllers if time had reached min reordering time.
- CheckControllersOrder(
- &states, rtc::Optional<int>(kChracteristicBandwithBps[1]),
- rtc::Optional<float>(kChracteristicPacketLossFraction[1]),
- {kNumControllers - 2, kNumControllers - 1, 0, 1});
+ CheckControllersOrder(&states, kChracteristicBandwithBps[1],
+ kChracteristicPacketLossFraction[1],
+ {kNumControllers - 2, kNumControllers - 1, 0, 1});
}
TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
@@ -171,16 +168,14 @@
2.0f;
// Set network metrics to be in the middle between the characteristic points
// of two controllers.
- CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
- rtc::Optional<float>(kPacketLossFraction),
+ CheckControllersOrder(&states, kBandwidthBps, kPacketLossFraction,
{kNumControllers - 2, kNumControllers - 1, 0, 1});
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
// Then let network metrics move a little towards the other controller.
- CheckControllersOrder(
- &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps - 1),
- rtc::Optional<float>(kPacketLossFraction),
- {kNumControllers - 2, kNumControllers - 1, 1, 0});
+ CheckControllersOrder(&states, kBandwidthBps - kMinBandwithChangeBps - 1,
+ kPacketLossFraction,
+ {kNumControllers - 2, kNumControllers - 1, 1, 0});
}
TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
@@ -193,16 +188,14 @@
2.0f;
// Set network metrics to be in the middle between the characteristic points
// of two controllers.
- CheckControllersOrder(&states, rtc::Optional<int>(kBandwidthBps),
- rtc::Optional<float>(kPacketLossFraction),
+ CheckControllersOrder(&states, kBandwidthBps, kPacketLossFraction,
{kNumControllers - 2, kNumControllers - 1, 0, 1});
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs));
// Then let network metrics move a little towards the other controller.
- CheckControllersOrder(
- &states, rtc::Optional<int>(kBandwidthBps - kMinBandwithChangeBps + 1),
- rtc::Optional<float>(kPacketLossFraction),
- {kNumControllers - 2, kNumControllers - 1, 0, 1});
+ CheckControllersOrder(&states, kBandwidthBps - kMinBandwithChangeBps + 1,
+ kPacketLossFraction,
+ {kNumControllers - 2, kNumControllers - 1, 0, 1});
}
#if WEBRTC_ENABLE_PROTOBUF
@@ -312,24 +305,19 @@
// initial values.
switch (expected_types[i]) {
case ControllerType::FEC:
- EXPECT_EQ(rtc::Optional<bool>(kInitialFecEnabled),
- encoder_config.enable_fec);
+ EXPECT_EQ(kInitialFecEnabled, encoder_config.enable_fec);
break;
case ControllerType::CHANNEL:
- EXPECT_EQ(rtc::Optional<size_t>(kIntialChannelsToEncode),
- encoder_config.num_channels);
+ EXPECT_EQ(kIntialChannelsToEncode, encoder_config.num_channels);
break;
case ControllerType::DTX:
- EXPECT_EQ(rtc::Optional<bool>(kInitialDtxEnabled),
- encoder_config.enable_dtx);
+ EXPECT_EQ(kInitialDtxEnabled, encoder_config.enable_dtx);
break;
case ControllerType::FRAME_LENGTH:
- EXPECT_EQ(rtc::Optional<int>(kInitialFrameLengthMs),
- encoder_config.frame_length_ms);
+ EXPECT_EQ(kInitialFrameLengthMs, encoder_config.frame_length_ms);
break;
case ControllerType::BIT_RATE:
- EXPECT_EQ(rtc::Optional<int>(kInitialBitrateBps),
- encoder_config.bitrate_bps);
+ EXPECT_EQ(kInitialBitrateBps, encoder_config.bitrate_bps);
}
}
}
@@ -448,10 +436,8 @@
auto states = CreateControllerManager(config_string);
Controller::NetworkMetrics metrics;
- metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(kChracteristicBandwithBps[0]);
- metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(kChracteristicPacketLossFraction[0]);
+ metrics.uplink_bandwidth_bps = kChracteristicBandwithBps[0];
+ metrics.uplink_packet_loss_fraction = kChracteristicPacketLossFraction[0];
auto controllers = states.controller_manager->GetSortedControllers(metrics);
CheckControllersOrder(controllers,
@@ -460,10 +446,8 @@
ControllerType::CHANNEL, ControllerType::DTX,
ControllerType::BIT_RATE});
- metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(kChracteristicBandwithBps[1]);
- metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(kChracteristicPacketLossFraction[1]);
+ metrics.uplink_bandwidth_bps = kChracteristicBandwithBps[1];
+ metrics.uplink_packet_loss_fraction = kChracteristicPacketLossFraction[1];
fake_clock.AdvanceTime(
rtc::TimeDelta::FromMilliseconds(kMinReorderingTimeMs - 1));
controllers = states.controller_manager->GetSortedControllers(metrics);
diff --git a/modules/audio_coding/audio_network_adaptor/dtx_controller.cc b/modules/audio_coding/audio_network_adaptor/dtx_controller.cc
index 7c7d6ad..cbfea95 100644
--- a/modules/audio_coding/audio_network_adaptor/dtx_controller.cc
+++ b/modules/audio_coding/audio_network_adaptor/dtx_controller.cc
@@ -44,7 +44,7 @@
dtx_enabled_ = true;
}
}
- config->enable_dtx = rtc::Optional<bool>(dtx_enabled_);
+ config->enable_dtx = dtx_enabled_;
}
} // namespace webrtc
diff --git a/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc b/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
index 2c58249..e38e65d 100644
--- a/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
@@ -39,7 +39,7 @@
}
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
- EXPECT_EQ(rtc::Optional<bool>(expected_dtx_enabled), config.enable_dtx);
+ EXPECT_EQ(expected_dtx_enabled, config.enable_dtx);
}
} // namespace
@@ -47,43 +47,35 @@
TEST(DtxControllerTest, OutputInitValueWhenUplinkBandwidthUnknown) {
constexpr bool kInitialDtxEnabled = true;
auto controller = CreateController(kInitialDtxEnabled);
- CheckDecision(controller.get(), rtc::Optional<int>(), kInitialDtxEnabled);
+ CheckDecision(controller.get(), rtc::nullopt, kInitialDtxEnabled);
}
TEST(DtxControllerTest, TurnOnDtxForLowUplinkBandwidth) {
auto controller = CreateController(false);
- CheckDecision(controller.get(), rtc::Optional<int>(kDtxEnablingBandwidthBps),
- true);
+ CheckDecision(controller.get(), kDtxEnablingBandwidthBps, true);
}
TEST(DtxControllerTest, TurnOffDtxForHighUplinkBandwidth) {
auto controller = CreateController(true);
- CheckDecision(controller.get(), rtc::Optional<int>(kDtxDisablingBandwidthBps),
- false);
+ CheckDecision(controller.get(), kDtxDisablingBandwidthBps, false);
}
TEST(DtxControllerTest, MaintainDtxOffForMediumUplinkBandwidth) {
auto controller = CreateController(false);
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps),
- false);
+ CheckDecision(controller.get(), kMediumBandwidthBps, false);
}
TEST(DtxControllerTest, MaintainDtxOnForMediumUplinkBandwidth) {
auto controller = CreateController(true);
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps),
- true);
+ CheckDecision(controller.get(), kMediumBandwidthBps, true);
}
TEST(DtxControllerTest, CheckBehaviorOnChangingUplinkBandwidth) {
auto controller = CreateController(false);
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps),
- false);
- CheckDecision(controller.get(), rtc::Optional<int>(kDtxEnablingBandwidthBps),
- true);
- CheckDecision(controller.get(), rtc::Optional<int>(kMediumBandwidthBps),
- true);
- CheckDecision(controller.get(), rtc::Optional<int>(kDtxDisablingBandwidthBps),
- false);
+ CheckDecision(controller.get(), kMediumBandwidthBps, false);
+ CheckDecision(controller.get(), kDtxEnablingBandwidthBps, true);
+ CheckDecision(controller.get(), kMediumBandwidthBps, true);
+ CheckDecision(controller.get(), kDtxDisablingBandwidthBps, false);
}
} // namespace webrtc
diff --git a/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc b/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
index ee8249a..df97594 100644
--- a/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
@@ -51,13 +51,12 @@
state.event_log_writer.reset(new EventLogWriter(
state.event_log.get(), kMinBitrateChangeBps, kMinBitrateChangeFraction,
kMinPacketLossChangeFraction));
- state.runtime_config.bitrate_bps = rtc::Optional<int>(kHighBitrateBps);
- state.runtime_config.frame_length_ms = rtc::Optional<int>(kFrameLengthMs);
- state.runtime_config.uplink_packet_loss_fraction =
- rtc::Optional<float>(kPacketLossFraction);
- state.runtime_config.enable_fec = rtc::Optional<bool>(kEnableFec);
- state.runtime_config.enable_dtx = rtc::Optional<bool>(kEnableDtx);
- state.runtime_config.num_channels = rtc::Optional<size_t>(kNumChannels);
+ state.runtime_config.bitrate_bps = kHighBitrateBps;
+ state.runtime_config.frame_length_ms = kFrameLengthMs;
+ state.runtime_config.uplink_packet_loss_fraction = kPacketLossFraction;
+ state.runtime_config.enable_fec = kEnableFec;
+ state.runtime_config.enable_dtx = kEnableDtx;
+ state.runtime_config.num_channels = kNumChannels;
return state;
}
} // namespace
@@ -86,7 +85,7 @@
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.enable_fec = rtc::Optional<bool>(!kEnableFec);
+ state.runtime_config.enable_fec = !kEnableFec;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -100,7 +99,7 @@
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.enable_dtx = rtc::Optional<bool>(!kEnableDtx);
+ state.runtime_config.enable_dtx = !kEnableDtx;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -114,7 +113,7 @@
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.num_channels = rtc::Optional<size_t>(kNumChannels + 1);
+ state.runtime_config.num_channels = kNumChannels + 1;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -128,7 +127,7 @@
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.frame_length_ms = rtc::Optional<int>(20);
+ state.runtime_config.frame_length_ms = 20;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -141,8 +140,7 @@
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.bitrate_bps =
- rtc::Optional<int>(kHighBitrateBps + kMinBitrateChangeBps - 1);
+ state.runtime_config.bitrate_bps = kHighBitrateBps + kMinBitrateChangeBps - 1;
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
}
@@ -156,8 +154,7 @@
// min change rule. We make sure that the min change rule applies.
RTC_DCHECK_GT(kHighBitrateBps * kMinBitrateChangeFraction,
kMinBitrateChangeBps);
- state.runtime_config.bitrate_bps =
- rtc::Optional<int>(kHighBitrateBps + kMinBitrateChangeBps);
+ state.runtime_config.bitrate_bps = kHighBitrateBps + kMinBitrateChangeBps;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -166,15 +163,15 @@
TEST(EventLogWriterTest, LogMinBitrateChangeFractionOnLowBitrateChange) {
auto state = CreateEventLogWriter();
- state.runtime_config.bitrate_bps = rtc::Optional<int>(kLowBitrateBps);
+ state.runtime_config.bitrate_bps = kLowBitrateBps;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
// At high bitrate, the min change rule requires a larger change than the min
// fraction rule. We make sure that the min fraction rule applies.
- state.runtime_config.bitrate_bps = rtc::Optional<int>(
- kLowBitrateBps + kLowBitrateBps * kMinBitrateChangeFraction);
+ state.runtime_config.bitrate_bps =
+ kLowBitrateBps + kLowBitrateBps * kMinBitrateChangeFraction;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -187,9 +184,9 @@
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
+ state.runtime_config.uplink_packet_loss_fraction =
kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction -
- 0.001f);
+ 0.001f;
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
}
@@ -199,8 +196,8 @@
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
- kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction);
+ state.runtime_config.uplink_packet_loss_fraction =
+ kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -213,9 +210,9 @@
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.uplink_packet_loss_fraction = rtc::Optional<float>(
- kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction);
- state.runtime_config.frame_length_ms = rtc::Optional<int>(20);
+ state.runtime_config.uplink_packet_loss_fraction =
+ kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction;
+ state.runtime_config.frame_length_ms = 20;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
@@ -228,14 +225,13 @@
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
- state.runtime_config.bitrate_bps =
- rtc::Optional<int>(kHighBitrateBps + kMinBitrateChangeBps);
+ state.runtime_config.bitrate_bps = kHighBitrateBps + kMinBitrateChangeBps;
EXPECT_CALL(*state.event_log,
LogProxy(IsRtcEventAnaConfigEqualTo(state.runtime_config)))
.Times(1);
for (int bitrate_bps = kHighBitrateBps;
bitrate_bps <= kHighBitrateBps + kMinBitrateChangeBps; bitrate_bps++) {
- state.runtime_config.bitrate_bps = rtc::Optional<int>(bitrate_bps);
+ state.runtime_config.bitrate_bps = bitrate_bps;
state.event_log_writer->MaybeLogEncoderConfig(state.runtime_config);
}
}
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
index 80cc695..62f356d 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
@@ -21,9 +21,7 @@
namespace {
class NullSmoothingFilter final : public SmoothingFilter {
public:
- void AddSample(float sample) override {
- last_sample_ = rtc::Optional<float>(sample);
- }
+ void AddSample(float sample) override { last_sample_ = sample; }
rtc::Optional<float> GetAverage() override { return last_sample_; }
@@ -85,10 +83,9 @@
fec_enabled_ = fec_enabled_ ? !FecDisablingDecision(packet_loss)
: FecEnablingDecision(packet_loss);
- config->enable_fec = rtc::Optional<bool>(fec_enabled_);
+ config->enable_fec = fec_enabled_;
- config->uplink_packet_loss_fraction =
- rtc::Optional<float>(packet_loss ? *packet_loss : 0.0);
+ config->uplink_packet_loss_fraction = packet_loss ? *packet_loss : 0.0;
}
bool FecControllerPlrBased::FecEnablingDecision(
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
index 41d959d..8636aa9 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
@@ -95,17 +95,10 @@
states->controller->UpdateNetworkMetrics(network_metrics);
// This is called during CheckDecision().
EXPECT_CALL(*states->packet_loss_smoother, GetAverage())
- .WillOnce(Return(rtc::Optional<float>(*uplink_packet_loss)));
+ .WillOnce(Return(*uplink_packet_loss));
}
}
-void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
- int uplink_bandwidth_bps,
- float uplink_packet_loss) {
- UpdateNetworkMetrics(states, rtc::Optional<int>(uplink_bandwidth_bps),
- rtc::Optional<float>(uplink_packet_loss));
-}
-
// Checks that the FEC decision and |uplink_packet_loss_fraction| given by
// |states->controller->MakeDecision| matches |expected_enable_fec| and
// |expected_uplink_packet_loss_fraction|, respectively.
@@ -114,8 +107,8 @@
float expected_uplink_packet_loss_fraction) {
AudioEncoderRuntimeConfig config;
states->controller->MakeDecision(&config);
- EXPECT_EQ(rtc::Optional<bool>(expected_enable_fec), config.enable_fec);
- EXPECT_EQ(rtc::Optional<float>(expected_uplink_packet_loss_fraction),
+ EXPECT_EQ(expected_enable_fec, config.enable_fec);
+ EXPECT_EQ(expected_uplink_packet_loss_fraction,
config.uplink_packet_loss_fraction);
}
@@ -138,8 +131,7 @@
kEnablingPacketLossAtLowBw - kEpsilon, kEnablingPacketLossAtLowBw,
kEnablingPacketLossAtLowBw + kEpsilon}) {
auto states = CreateFecControllerPlrBased(initial_fec_enabled);
- UpdateNetworkMetrics(&states, rtc::Optional<int>(),
- rtc::Optional<float>(packet_loss));
+ UpdateNetworkMetrics(&states, rtc::nullopt, packet_loss);
CheckDecision(&states, initial_fec_enabled, packet_loss);
}
}
@@ -154,8 +146,7 @@
kDisablingBandwidthLow + 1, kEnablingBandwidthLow - 1,
kEnablingBandwidthLow, kEnablingBandwidthLow + 1}) {
auto states = CreateFecControllerPlrBased(initial_fec_enabled);
- UpdateNetworkMetrics(&states, rtc::Optional<int>(bandwidth),
- rtc::Optional<float>());
+ UpdateNetworkMetrics(&states, bandwidth, rtc::nullopt);
CheckDecision(&states, initial_fec_enabled, 0.0);
}
}
@@ -178,12 +169,10 @@
// audio_network_adaptor_impl.cc.
auto states = CreateFecControllerPlrBased(false);
Controller::NetworkMetrics network_metrics;
- network_metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(kEnablingBandwidthHigh);
- network_metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(kEnablingPacketLossAtHighBw);
+ network_metrics.uplink_bandwidth_bps = kEnablingBandwidthHigh;
+ network_metrics.uplink_packet_loss_fraction = kEnablingPacketLossAtHighBw;
EXPECT_CALL(*states.packet_loss_smoother, GetAverage())
- .WillOnce(Return(rtc::Optional<float>(kEnablingPacketLossAtHighBw)));
+ .WillOnce(Return(kEnablingPacketLossAtHighBw));
states.controller->UpdateNetworkMetrics(network_metrics);
CheckDecision(&states, true, kEnablingPacketLossAtHighBw);
}
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
index eb56ea0..c8cfd31 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
@@ -48,9 +48,9 @@
fec_enabled_ = fec_enabled_ ? !FecDisablingDecision() : FecEnablingDecision();
- config->enable_fec = rtc::Optional<bool>(fec_enabled_);
- config->uplink_packet_loss_fraction = rtc::Optional<float>(
- uplink_recoverable_packet_loss_ ? *uplink_recoverable_packet_loss_ : 0.0);
+ config->enable_fec = fec_enabled_;
+ config->uplink_packet_loss_fraction =
+ uplink_recoverable_packet_loss_ ? *uplink_recoverable_packet_loss_ : 0.0;
}
bool FecControllerRplrBased::FecEnablingDecision() const {
diff --git a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
index f20122f..0fc003b 100644
--- a/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
@@ -49,11 +49,9 @@
std::mt19937 generator(rd());
std::uniform_real_distribution<> distribution(0, 1);
- if (distribution(generator) < 0.2) {
- return rtc::Optional<float>();
- } else {
- return rtc::Optional<float>(distribution(generator));
- }
+ return (distribution(generator) < 0.2)
+ ? rtc::nullopt
+ : rtc::Optional<float>(distribution(generator));
}
std::unique_ptr<FecControllerRplrBased> CreateFecControllerRplrBased(
@@ -108,13 +106,6 @@
uplink_recoveralbe_packet_loss);
}
-void UpdateNetworkMetrics(FecControllerRplrBased* controller,
- int uplink_bandwidth_bps,
- float uplink_recoveralbe_packet_loss) {
- UpdateNetworkMetrics(controller, rtc::Optional<int>(uplink_bandwidth_bps),
- rtc::Optional<float>(uplink_recoveralbe_packet_loss));
-}
-
// Checks that the FEC decision and |uplink_packet_loss_fraction| given by
// |states->controller->MakeDecision| matches |expected_enable_fec| and
// |expected_uplink_packet_loss_fraction|, respectively.
@@ -157,8 +148,8 @@
kEnablingRecoverablePacketLossAtHighBw,
kEnablingRecoverablePacketLossAtHighBw + kEpsilon}) {
auto controller = CreateFecControllerRplrBased(initial_fec_enabled);
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(),
- rtc::Optional<float>(recoverable_packet_loss));
+ UpdateNetworkMetrics(controller.get(), rtc::nullopt,
+ recoverable_packet_loss);
CheckDecision(controller.get(), initial_fec_enabled,
recoverable_packet_loss);
}
@@ -174,8 +165,7 @@
kDisablingBandwidthLow + 1, kEnablingBandwidthLow - 1,
kEnablingBandwidthLow, kEnablingBandwidthLow + 1}) {
auto controller = CreateFecControllerRplrBased(initial_fec_enabled);
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(bandwidth),
- rtc::Optional<float>());
+ UpdateNetworkMetrics(controller.get(), bandwidth, rtc::nullopt);
CheckDecision(controller.get(), initial_fec_enabled, 0.0);
}
}
@@ -198,12 +188,10 @@
// audio_network_adaptor_impl.cc.
auto controller = CreateFecControllerRplrBased(false);
Controller::NetworkMetrics network_metrics;
- network_metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(kEnablingBandwidthHigh);
- network_metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(GetRandomProbabilityOrUnknown());
+ network_metrics.uplink_bandwidth_bps = kEnablingBandwidthHigh;
+ network_metrics.uplink_packet_loss_fraction = GetRandomProbabilityOrUnknown();
network_metrics.uplink_recoverable_packet_loss_fraction =
- rtc::Optional<float>(kEnablingRecoverablePacketLossAtHighBw);
+ kEnablingRecoverablePacketLossAtHighBw;
controller->UpdateNetworkMetrics(network_metrics);
CheckDecision(controller.get(), true, kEnablingRecoverablePacketLossAtHighBw);
}
diff --git a/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc b/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
index 5ae78b0..6c3cae0 100644
--- a/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
+++ b/modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
@@ -82,7 +82,7 @@
prev_decision_increase_ = false;
}
config->last_fl_change_increase = prev_decision_increase_;
- config->frame_length_ms = rtc::Optional<int>(*frame_length_ms_);
+ config->frame_length_ms = *frame_length_ms_;
}
FrameLengthController::Config::FrameLengthChange::FrameLengthChange(
diff --git a/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc b/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
index 4c96c96..1f98447 100644
--- a/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
+++ b/modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
@@ -105,8 +105,7 @@
int expected_frame_length_ms) {
AudioEncoderRuntimeConfig config;
controller->MakeDecision(&config);
- EXPECT_EQ(rtc::Optional<int>(expected_frame_length_ms),
- config.frame_length_ms);
+ EXPECT_EQ(expected_frame_length_ms, config.frame_length_ms);
}
} // namespace
@@ -114,18 +113,17 @@
TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkBandwidth) {
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 60);
- UpdateNetworkMetrics(
- controller.get(), rtc::Optional<int>(kFl60msTo20msBandwidthBps),
- rtc::Optional<float>(), rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
+ rtc::nullopt, kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkPacketLossFraction) {
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 60);
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), rtc::nullopt,
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -145,10 +143,8 @@
// 3. FEC is not decided ON.
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 60);
- UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kMediumBandwidthBps),
- rtc::Optional<float>(kMediumPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), kMediumBandwidthBps,
+ kMediumPacketLossFraction, kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -160,10 +156,9 @@
// 3. FEC is not decided or OFF.
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 20);
- UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl20msTo60msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), kFl20msTo60msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -173,9 +168,9 @@
// We set packet loss fraction to kFlDecreasingPacketLossFraction, which
// should have prevented frame length to increase, if the uplink bandwidth
// was not this low.
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(VeryLowBitrate(20)),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), VeryLowBitrate(20),
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -185,9 +180,9 @@
// We set packet loss fraction to FlDecreasingPacketLossFraction, which should
// have caused the frame length to decrease, if the uplink bandwidth was not
// this low.
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(VeryLowBitrate(20)),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), VeryLowBitrate(20),
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -202,10 +197,8 @@
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 20);
Controller::NetworkMetrics network_metrics;
- network_metrics.uplink_bandwidth_bps =
- rtc::Optional<int>(kFl20msTo60msBandwidthBps);
- network_metrics.uplink_packet_loss_fraction =
- rtc::Optional<float>(kFlIncreasingPacketLossFraction);
+ network_metrics.uplink_bandwidth_bps = kFl20msTo60msBandwidthBps;
+ network_metrics.uplink_packet_loss_fraction = kFlIncreasingPacketLossFraction;
controller->UpdateNetworkMetrics(network_metrics);
CheckDecision(controller.get(), 60);
}
@@ -217,9 +210,9 @@
// Use a low uplink bandwidth and a low uplink packet loss fraction that would
// cause frame length to increase if receiver frame length included 60ms.
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl20msTo60msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl20msTo60msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -227,9 +220,9 @@
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60}, 20);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kMediumBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kMediumBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -239,9 +232,9 @@
// Use a low uplink bandwidth that would cause frame length to increase if
// uplink packet loss fraction was low.
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl20msTo60msBandwidthBps),
- rtc::Optional<float>(kMediumPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl20msTo60msBandwidthBps,
+ kMediumPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -249,9 +242,9 @@
auto controller =
CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20, 60, 120}, 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -259,14 +252,16 @@
auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
{20, 60, 120}, 120);
// It takes two steps for frame length to go from 120ms to 20ms.
- UpdateNetworkMetrics(
- controller.get(), rtc::Optional<int>(kFl60msTo20msBandwidthBps),
- rtc::Optional<float>(), rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(),
+ kFl60msTo20msBandwidthBps,
+ rtc::nullopt,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
- UpdateNetworkMetrics(
- controller.get(), rtc::Optional<int>(kFl60msTo20msBandwidthBps),
- rtc::Optional<float>(), rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(),
+ kFl60msTo20msBandwidthBps,
+ rtc::nullopt,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -274,14 +269,14 @@
auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
{20, 60, 120}, 120);
// It takes two steps for frame length to go from 120ms to 20ms.
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), rtc::nullopt,
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), rtc::nullopt,
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}
@@ -291,9 +286,9 @@
// We set packet loss fraction to FlDecreasingPacketLossFraction, which should
// have caused the frame length to decrease, if the uplink bandwidth was not
// this low.
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(VeryLowBitrate(60)),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), VeryLowBitrate(60),
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 120);
}
@@ -303,9 +298,9 @@
// We set packet loss fraction to FlDecreasingPacketLossFraction, which should
// have prevented frame length to increase, if the uplink bandwidth was not
// this low.
- UpdateNetworkMetrics(controller.get(), rtc::Optional<int>(VeryLowBitrate(60)),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ UpdateNetworkMetrics(controller.get(), VeryLowBitrate(60),
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 120);
}
@@ -317,14 +312,14 @@
{20, 60, 120}, 20);
// It takes two steps for frame length to go from 20ms to 120ms.
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 120);
}
@@ -332,14 +327,14 @@
auto controller =
CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(), {20, 60}, 20);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
}
@@ -347,39 +342,39 @@
auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
{20, 60, 120}, 20);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kMediumBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kMediumBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl20msTo60msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl20msTo60msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kMediumPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kMediumPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl60msTo120msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl60msTo120msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 120);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kFl120msTo60msBandwidthBps),
- rtc::Optional<float>(kFlIncreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kFl120msTo60msBandwidthBps,
+ kFlIncreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 60);
UpdateNetworkMetrics(controller.get(),
- rtc::Optional<int>(kMediumBandwidthBps),
- rtc::Optional<float>(kFlDecreasingPacketLossFraction),
- rtc::Optional<size_t>(kOverheadBytesPerPacket));
+ kMediumBandwidthBps,
+ kFlDecreasingPacketLossFraction,
+ kOverheadBytesPerPacket);
CheckDecision(controller.get(), 20);
}