zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Optional: Use nullopt and implicit construction in /modules/audio_coding

Browse Source 
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}
This commit is contained in:
Oskar Sundbom
2017-11-16 15:31:38 +01:00
committed by Commit Bot
parent f715c53bca
commit 12ab00b4d8
49 changed files with 435 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.cc
View File

@ -58,68 +58,61 @@ AudioNetworkAdaptorImpl::AudioNetworkAdaptorImpl(
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 @@ AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
// 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 @@ AudioEncoderRuntimeConfig AudioNetworkAdaptorImpl::GetEncoderRuntimeConfig() {
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) {

58
modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl_unittest.cc
View File

@ -124,7 +124,7 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest, UpdateNetworkMetricsIsCalledOnSetRtt) {
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest, UpdateNetworkMetricsIsCalledOnSetOverhead) {
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest,
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 @@ TEST(AudioNetworkAdaptorImplTest, LogRuntimeConfigOnGetEncoderRuntimeConfig) {
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 @@ TEST(AudioNetworkAdaptorImplTest, TestANAStats) {
// 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));

2
modules/audio_coding/audio_network_adaptor/bitrate_controller.cc
View File

@ -69,7 +69,7 @@ void BitrateController::MakeDecision(AudioEncoderRuntimeConfig* config) {
(*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

95
modules/audio_coding/audio_network_adaptor/bitrate_controller_unittest.cc
View File

@ -43,7 +43,7 @@ void CheckDecision(BitrateController* controller,
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 @@ TEST(AnaBitrateControllerTest, OutputInitValueWhenTargetBitrateUnknown) {
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 @@ TEST(AnaBitrateControllerTest, OutputInitValueWhenOverheadUnknown) {
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 @@ TEST(AnaBitrateControllerTest, ChangeBitrateOnTargetBitrateChanged) {
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 @@ TEST(AnaBitrateControllerTest, UpdateMultipleNetworkMetricsAtOnce) {
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 @@ TEST(AnaBitrateControllerTest, TreatUnknownFrameLengthAsFrameLengthUnchanged) {
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 @@ TEST(AnaBitrateControllerTest, IncreaseBitrateOnFrameLengthIncreased) {
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 @@ TEST(AnaBitrateControllerTest, DecreaseBitrateOnFrameLengthDecreased) {
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 @@ TEST(AnaBitrateControllerTest, BitrateNeverBecomesNegative) {
// 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 @@ TEST(AnaBitrateControllerTest, CheckBehaviorOnChangingCondition) {
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 @@ TEST(AnaBitrateControllerTest, CheckBehaviorOnChangingCondition) {
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

2
modules/audio_coding/audio_network_adaptor/channel_controller.cc
View File

@ -55,7 +55,7 @@ void ChannelController::MakeDecision(AudioEncoderRuntimeConfig* config) {
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

24
modules/audio_coding/audio_network_adaptor/channel_controller_unittest.cc
View File

@ -41,7 +41,7 @@ void CheckDecision(ChannelController* controller,
}
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 @@ void CheckDecision(ChannelController* controller,
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 @@ TEST(ChannelControllerTest, CheckBehaviorOnChangingUplinkBandwidth) {
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

4
modules/audio_coding/audio_network_adaptor/controller_manager.cc
View File

@ -327,7 +327,7 @@ ControllerManagerImpl::ControllerManagerImpl(
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 @@ std::vector<Controller*> ControllerManagerImpl::GetSortedControllers(
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_;

74
modules/audio_coding/audio_network_adaptor/controller_manager_unittest.cc
View File

@ -124,41 +124,38 @@ TEST(ControllerManagerTest, ControllersInDefaultOrderOnEmptyNetworkMetrics) {
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 @@ TEST(ControllerManagerTest, ReorderBeyondMinReordingTimeAndMinDistance) {
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 @@ TEST(ControllerManagerTest, DoNotReorderIfNetworkMetricsChangeTooSmall) {
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 @@ void CheckControllersOrder(const std::vector<Controller*>& controllers,
// 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 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
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 @@ TEST(ControllerManagerTest, CreateFromConfigStringAndCheckReordering) {
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);

2
modules/audio_coding/audio_network_adaptor/dtx_controller.cc
View File

@ -44,7 +44,7 @@ void DtxController::MakeDecision(AudioEncoderRuntimeConfig* config) {
dtx_enabled_ = true;
}
}
config->enable_dtx = rtc::Optional<bool>(dtx_enabled_);
config->enable_dtx = dtx_enabled_;
}
} // namespace webrtc

28
modules/audio_coding/audio_network_adaptor/dtx_controller_unittest.cc
View File

@ -39,7 +39,7 @@ void CheckDecision(DtxController* controller,
}
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 @@ void CheckDecision(DtxController* controller,
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

52
modules/audio_coding/audio_network_adaptor/event_log_writer_unittest.cc
View File

@ -51,13 +51,12 @@ EventLogWriterStates CreateEventLogWriter() {
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 @@ TEST(EventLogWriterTest, LogFecStateChange) {
.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 @@ TEST(EventLogWriterTest, LogDtxStateChange) {
.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 @@ TEST(EventLogWriterTest, LogChannelChange) {
.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 @@ TEST(EventLogWriterTest, LogFrameLengthChange) {
.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 @@ TEST(EventLogWriterTest, DoNotLogSmallBitrateChange) {
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 @@ TEST(EventLogWriterTest, LogLargeBitrateChange) {
// 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, LogLargeBitrateChange) {
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 @@ TEST(EventLogWriterTest, DoNotLogSmallPacketLossFractionChange) {
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 @@ TEST(EventLogWriterTest, LogLargePacketLossFractionChange) {
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 @@ TEST(EventLogWriterTest, LogJustOnceOnMultipleChanges) {
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 @@ TEST(EventLogWriterTest, LogAfterGradualChange) {
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);
}
}

9
modules/audio_coding/audio_network_adaptor/fec_controller_plr_based.cc
View File

@ -21,9 +21,7 @@ namespace webrtc {
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 @@ void FecControllerPlrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
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(

27
modules/audio_coding/audio_network_adaptor/fec_controller_plr_based_unittest.cc
View File

@ -95,17 +95,10 @@ void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states,
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 @@ void CheckDecision(FecControllerPlrBasedTestStates* states,
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 @@ TEST(FecControllerPlrBasedTest, OutputInitValueWhenUplinkBandwidthUnknown) {
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 @@ TEST(FecControllerPlrBasedTest,
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 @@ TEST(FecControllerPlrBasedTest, UpdateMultipleNetworkMetricsAtOnce) {
// 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);
}

6
modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based.cc
View File

@ -48,9 +48,9 @@ void FecControllerRplrBased::MakeDecision(AudioEncoderRuntimeConfig* config) {
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 {

30
modules/audio_coding/audio_network_adaptor/fec_controller_rplr_based_unittest.cc
View File

@ -49,11 +49,9 @@ rtc::Optional<float> GetRandomProbabilityOrUnknown() {
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 @@ void UpdateNetworkMetrics(
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 @@ TEST(FecControllerRplrBasedTest, OutputInitValueWhenUplinkBandwidthUnknown) {
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 @@ TEST(FecControllerRplrBasedTest,
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 @@ TEST(FecControllerRplrBasedTest, UpdateMultipleNetworkMetricsAtOnce) {
// 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);
}

2
modules/audio_coding/audio_network_adaptor/frame_length_controller.cc
View File

@ -82,7 +82,7 @@ void FrameLengthController::MakeDecision(AudioEncoderRuntimeConfig* config) {
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(

167
modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc
View File

@ -105,8 +105,7 @@ void CheckDecision(FrameLengthController* controller,
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 @@ void CheckDecision(FrameLengthController* controller,
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 @@ TEST(FrameLengthControllerTest, Maintain60MsOnMultipleConditions) {
// 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 @@ TEST(FrameLengthControllerTest, IncreaseTo60MsOnMultipleConditions) {
// 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 @@ TEST(FrameLengthControllerTest, IncreaseTo60MsOnVeryLowUplinkBandwidth) {
// 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 @@ TEST(FrameLengthControllerTest, Maintain60MsOnVeryLowUplinkBandwidth) {
// 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 @@ TEST(FrameLengthControllerTest, UpdateMultipleNetworkMetricsAtOnce) {
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 @@ TEST(FrameLengthControllerTest,
// 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 @@ TEST(FrameLengthControllerTest, Maintain20MsOnMediumUplinkBandwidth) {
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 @@ TEST(FrameLengthControllerTest, Maintain20MsOnMediumUplinkPacketLossFraction) {
// 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 @@ TEST(FrameLengthControllerTest, Maintain60MsWhenNo120msCriteriaIsSet) {
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 @@ TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkBandwidth) {
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 @@ TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkPacketLossFraction) {
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 @@ TEST(FrameLengthControllerTest, Maintain120MsOnVeryLowUplinkBandwidth) {
// 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 @@ TEST(FrameLengthControllerTest, From60MsTo120MsOnVeryLowUplinkBandwidth) {
// 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 @@ TEST(FrameLengthControllerTest, From20MsTo120MsOnMultipleConditions) {
{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 @@ TEST(FrameLengthControllerTest, Stall60MsIf120MsNotInReceiverFrameLengthRange) {
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 @@ TEST(FrameLengthControllerTest, CheckBehaviorOnChangingNetworkMetrics) {
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);
}