From 12ab00b4d856d8f8f2fe30ed991bcf4b87e5c392 Mon Sep 17 00:00:00 2001 From: Oskar Sundbom Date: Thu, 16 Nov 2017 15:31:38 +0100 Subject: [PATCH] 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 Reviewed-by: Karl Wiberg Reviewed-by: Elad Alon Cr-Commit-Position: refs/heads/master@{#20728} --- modules/audio_coding/acm2/acm_receiver.cc | 14 +- .../acm2/acm_receiver_unittest.cc | 6 +- .../audio_coding/acm2/audio_coding_module.cc | 12 +- .../acm2/audio_coding_module_unittest.cc | 6 +- modules/audio_coding/acm2/codec_manager.cc | 2 +- modules/audio_coding/acm2/codec_manager.h | 2 +- modules/audio_coding/acm2/rent_a_codec.cc | 17 +- modules/audio_coding/acm2/rent_a_codec.h | 4 +- .../audio_network_adaptor_impl.cc | 38 ++-- .../audio_network_adaptor_impl_unittest.cc | 58 +++--- .../bitrate_controller.cc | 2 +- .../bitrate_controller_unittest.cc | 95 ++++------ .../channel_controller.cc | 2 +- .../channel_controller_unittest.cc | 24 ++- .../controller_manager.cc | 4 +- .../controller_manager_unittest.cc | 74 +++----- .../audio_network_adaptor/dtx_controller.cc | 2 +- .../dtx_controller_unittest.cc | 28 ++- .../event_log_writer_unittest.cc | 52 +++--- .../fec_controller_plr_based.cc | 9 +- .../fec_controller_plr_based_unittest.cc | 27 +-- .../fec_controller_rplr_based.cc | 6 +- .../fec_controller_rplr_based_unittest.cc | 30 +--- .../frame_length_controller.cc | 2 +- .../frame_length_controller_unittest.cc | 167 +++++++++--------- .../codecs/cng/audio_encoder_cng_unittest.cc | 2 +- .../codecs/legacy_encoded_audio_frame.cc | 4 +- .../codecs/opus/audio_decoder_opus.cc | 4 +- .../codecs/opus/audio_encoder_opus.cc | 38 ++-- .../opus/audio_encoder_opus_unittest.cc | 70 +++----- .../codecs/opus/opus_complexity_unittest.cc | 8 +- .../red/audio_encoder_copy_red_unittest.cc | 2 +- .../neteq/audio_decoder_unittest.cc | 2 +- .../audio_coding/neteq/decoder_database.cc | 5 +- .../audio_coding/neteq/neteq_decoder_enum.cc | 68 ++++--- modules/audio_coding/neteq/neteq_impl.cc | 15 +- .../audio_coding/neteq/neteq_impl_unittest.cc | 5 +- .../neteq/neteq_network_stats_unittest.cc | 5 +- modules/audio_coding/neteq/packet_buffer.cc | 11 +- .../neteq/packet_buffer_unittest.cc | 20 +-- .../neteq/tools/encode_neteq_input.cc | 6 +- .../neteq/tools/fake_decode_from_file.cc | 3 +- .../neteq/tools/neteq_delay_analyzer.cc | 17 +- .../audio_coding/neteq/tools/neteq_input.h | 4 +- .../neteq/tools/neteq_packet_source_input.cc | 13 +- .../neteq/tools/neteq_replacement_input.cc | 2 +- .../audio_coding/neteq/tools/neteq_rtpplay.cc | 14 +- modules/audio_coding/test/APITest.cc | 2 +- modules/audio_coding/test/PCMFile.cc | 2 +- 49 files changed, 435 insertions(+), 570 deletions(-) diff --git a/modules/audio_coding/acm2/acm_receiver.cc b/modules/audio_coding/acm2/acm_receiver.cc index 360a583bb7..8f8b273033 100644 --- a/modules/audio_coding/acm2/acm_receiver.cc +++ b/modules/audio_coding/acm2/acm_receiver.cc @@ -103,7 +103,7 @@ int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header, last_audio_decoder_ = ci; last_audio_format_ = neteq_->GetDecoderFormat(ci->pltype); RTC_DCHECK(last_audio_format_); - last_packet_sample_rate_hz_ = rtc::Optional(ci->plfreq); + last_packet_sample_rate_hz_ = ci->plfreq; } } // |crit_sect_| is released. @@ -272,9 +272,9 @@ void AcmReceiver::FlushBuffers() { void AcmReceiver::RemoveAllCodecs() { rtc::CritScope lock(&crit_sect_); neteq_->RemoveAllPayloadTypes(); - last_audio_decoder_ = rtc::Optional(); - last_audio_format_ = rtc::Optional(); - last_packet_sample_rate_hz_ = rtc::Optional(); + last_audio_decoder_ = rtc::nullopt; + last_audio_format_ = rtc::nullopt; + last_packet_sample_rate_hz_ = rtc::nullopt; } int AcmReceiver::RemoveCodec(uint8_t payload_type) { @@ -285,9 +285,9 @@ int AcmReceiver::RemoveCodec(uint8_t payload_type) { return -1; } if (last_audio_decoder_ && payload_type == last_audio_decoder_->pltype) { - last_audio_decoder_ = rtc::Optional(); - last_audio_format_ = rtc::Optional(); - last_packet_sample_rate_hz_ = rtc::Optional(); + last_audio_decoder_ = rtc::nullopt; + last_audio_format_ = rtc::nullopt; + last_packet_sample_rate_hz_ = rtc::nullopt; } return 0; } diff --git a/modules/audio_coding/acm2/acm_receiver_unittest.cc b/modules/audio_coding/acm2/acm_receiver_unittest.cc index c420c7eb6f..e8f8b4a92d 100644 --- a/modules/audio_coding/acm2/acm_receiver_unittest.cc +++ b/modules/audio_coding/acm2/acm_receiver_unittest.cc @@ -483,8 +483,7 @@ TEST_F(AcmReceiverTestOldApi, MAYBE_LastAudioCodec) { // of type "speech." ASSERT_TRUE(packet_sent_); ASSERT_EQ(kAudioFrameSpeech, last_frame_type_); - EXPECT_EQ(rtc::Optional(c.inst.plfreq), - receiver_->last_packet_sample_rate_hz()); + EXPECT_EQ(c.inst.plfreq, receiver_->last_packet_sample_rate_hz()); // Set VAD on to send DTX. Then check if the "Last Audio codec" returns // the expected codec. @@ -496,8 +495,7 @@ TEST_F(AcmReceiverTestOldApi, MAYBE_LastAudioCodec) { InsertOnePacketOfSilence(c.id); ASSERT_TRUE(packet_sent_); } - EXPECT_EQ(rtc::Optional(c.inst.plfreq), - receiver_->last_packet_sample_rate_hz()); + EXPECT_EQ(c.inst.plfreq, receiver_->last_packet_sample_rate_hz()); EXPECT_EQ(0, receiver_->LastAudioCodec(&codec)); EXPECT_TRUE(CodecsEqual(c.inst, codec)); } diff --git a/modules/audio_coding/acm2/audio_coding_module.cc b/modules/audio_coding/acm2/audio_coding_module.cc index 361278f225..340cc92fab 100644 --- a/modules/audio_coding/acm2/audio_coding_module.cc +++ b/modules/audio_coding/acm2/audio_coding_module.cc @@ -606,21 +606,20 @@ rtc::Optional AudioCodingModuleImpl::SendCodec() const { if (encoder_factory_) { auto* ci = encoder_factory_->codec_manager.GetCodecInst(); if (ci) { - return rtc::Optional(*ci); + return *ci; } CreateSpeechEncoderIfNecessary(encoder_factory_.get()); const std::unique_ptr& enc = encoder_factory_->codec_manager.GetStackParams()->speech_encoder; if (enc) { - return rtc::Optional( - acm2::CodecManager::ForgeCodecInst(enc.get())); + return acm2::CodecManager::ForgeCodecInst(enc.get()); } - return rtc::Optional(); + return rtc::nullopt; } else { return encoder_stack_ ? rtc::Optional( acm2::CodecManager::ForgeCodecInst(encoder_stack_.get())) - : rtc::Optional(); + : rtc::nullopt; } } @@ -639,8 +638,7 @@ int AudioCodingModuleImpl::SendFrequency() const { void AudioCodingModuleImpl::SetBitRate(int bitrate_bps) { rtc::CritScope lock(&acm_crit_sect_); if (encoder_stack_) { - encoder_stack_->OnReceivedUplinkBandwidth(bitrate_bps, - rtc::Optional()); + encoder_stack_->OnReceivedUplinkBandwidth(bitrate_bps, rtc::nullopt); } } diff --git a/modules/audio_coding/acm2/audio_coding_module_unittest.cc b/modules/audio_coding/acm2/audio_coding_module_unittest.cc index ca59b31efa..68dd671415 100644 --- a/modules/audio_coding/acm2/audio_coding_module_unittest.cc +++ b/modules/audio_coding/acm2/audio_coding_module_unittest.cc @@ -184,8 +184,7 @@ class AudioCodingModuleTestOldApi : public ::testing::Test { // Set up L16 codec. virtual void SetUpL16Codec() { - audio_format_ = - rtc::Optional(SdpAudioFormat("L16", kSampleRateHz, 1)); + audio_format_ = SdpAudioFormat("L16", kSampleRateHz, 1); ASSERT_EQ(0, AudioCodingModule::Codec("L16", &codec_, kSampleRateHz, 1)); codec_.pltype = kPayloadType; } @@ -660,8 +659,7 @@ class AcmIsacMtTestOldApi : public AudioCodingModuleMtTestOldApi { void RegisterCodec() override { static_assert(kSampleRateHz == 16000, "test designed for iSAC 16 kHz"); - audio_format_ = - rtc::Optional(SdpAudioFormat("isac", kSampleRateHz, 1)); + audio_format_ = SdpAudioFormat("isac", kSampleRateHz, 1); AudioCodingModule::Codec("ISAC", &codec_, kSampleRateHz, 1); codec_.pltype = kPayloadType; diff --git a/modules/audio_coding/acm2/codec_manager.cc b/modules/audio_coding/acm2/codec_manager.cc index 50ef9efa4b..a101d3debb 100644 --- a/modules/audio_coding/acm2/codec_manager.cc +++ b/modules/audio_coding/acm2/codec_manager.cc @@ -106,7 +106,7 @@ bool CodecManager::RegisterEncoder(const CodecInst& send_codec) { codec_stack_params_.use_cng = false; } - send_codec_inst_ = rtc::Optional(send_codec); + send_codec_inst_ = send_codec; recreate_encoder_ = true; // Caller must recreate it. return true; } diff --git a/modules/audio_coding/acm2/codec_manager.h b/modules/audio_coding/acm2/codec_manager.h index a2a6810fcb..7485426cea 100644 --- a/modules/audio_coding/acm2/codec_manager.h +++ b/modules/audio_coding/acm2/codec_manager.h @@ -43,7 +43,7 @@ class CodecManager final { return send_codec_inst_ ? &*send_codec_inst_ : nullptr; } - void UnsetCodecInst() { send_codec_inst_ = rtc::Optional(); } + void UnsetCodecInst() { send_codec_inst_ = rtc::nullopt; } const RentACodec::StackParameters* GetStackParams() const { return &codec_stack_params_; diff --git a/modules/audio_coding/acm2/rent_a_codec.cc b/modules/audio_coding/acm2/rent_a_codec.cc index 39efd96148..78db38dad6 100644 --- a/modules/audio_coding/acm2/rent_a_codec.cc +++ b/modules/audio_coding/acm2/rent_a_codec.cc @@ -55,7 +55,7 @@ rtc::Optional RentACodec::CodecIdByParams( rtc::Optional RentACodec::CodecInstById(CodecId codec_id) { rtc::Optional mi = CodecIndexFromId(codec_id); return mi ? rtc::Optional(Database()[*mi]) - : rtc::Optional(); + : rtc::nullopt; } rtc::Optional RentACodec::CodecIdByInst( @@ -69,7 +69,7 @@ rtc::Optional RentACodec::CodecInstByParams(const char* payload_name, rtc::Optional codec_id = CodecIdByParams(payload_name, sampling_freq_hz, channels); if (!codec_id) - return rtc::Optional(); + return rtc::nullopt; rtc::Optional ci = CodecInstById(*codec_id); RTC_DCHECK(ci); @@ -90,7 +90,7 @@ rtc::Optional RentACodec::IsSupportedNumChannels(CodecId codec_id, return i ? rtc::Optional( ACMCodecDB::codec_settings_[*i].channel_support >= num_channels) - : rtc::Optional(); + : rtc::nullopt; } rtc::ArrayView RentACodec::Database() { @@ -103,12 +103,11 @@ rtc::Optional RentACodec::NetEqDecoderFromCodecId( size_t num_channels) { rtc::Optional i = CodecIndexFromId(codec_id); if (!i) - return rtc::Optional(); + return rtc::nullopt; const NetEqDecoder ned = ACMCodecDB::neteq_decoders_[*i]; - return rtc::Optional( - (ned == NetEqDecoder::kDecoderOpus && num_channels == 2) - ? NetEqDecoder::kDecoderOpus_2ch - : ned); + return (ned == NetEqDecoder::kDecoderOpus && num_channels == 2) + ? NetEqDecoder::kDecoderOpus_2ch + : ned; } RentACodec::RegistrationResult RentACodec::RegisterCngPayloadType( @@ -277,7 +276,7 @@ std::unique_ptr RentACodec::RentEncoderStack( auto pt = [¶m](const std::map& m) { auto it = m.find(param->speech_encoder->SampleRateHz()); - return it == m.end() ? rtc::Optional() + return it == m.end() ? rtc::nullopt : rtc::Optional(it->second); }; auto cng_pt = pt(param->cng_payload_types); diff --git a/modules/audio_coding/acm2/rent_a_codec.h b/modules/audio_coding/acm2/rent_a_codec.h index cecb914e72..f8fac4c01b 100644 --- a/modules/audio_coding/acm2/rent_a_codec.h +++ b/modules/audio_coding/acm2/rent_a_codec.h @@ -111,14 +111,14 @@ class RentACodec { const int i = static_cast(codec_id); return i >= 0 && i < static_cast(NumberOfCodecs()) ? rtc::Optional(i) - : rtc::Optional(); + : rtc::nullopt; } static inline rtc::Optional CodecIdFromIndex(int codec_index) { return static_cast(codec_index) < NumberOfCodecs() ? rtc::Optional( static_cast(codec_index)) - : rtc::Optional(); + : rtc::nullopt; } static rtc::Optional CodecIdByParams(const char* payload_name, 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 54423e67b9..55e53094c4 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( AudioNetworkAdaptorImpl::~AudioNetworkAdaptorImpl() = default; void AudioNetworkAdaptorImpl::SetUplinkBandwidth(int uplink_bandwidth_bps) { - last_metrics_.uplink_bandwidth_bps = rtc::Optional(uplink_bandwidth_bps); + last_metrics_.uplink_bandwidth_bps = uplink_bandwidth_bps; DumpNetworkMetrics(); Controller::NetworkMetrics network_metrics; - network_metrics.uplink_bandwidth_bps = - rtc::Optional(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(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(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(uplink_recoverable_packet_loss_fraction); + uplink_recoverable_packet_loss_fraction; DumpNetworkMetrics(); Controller::NetworkMetrics network_metrics; network_metrics.uplink_recoverable_packet_loss_fraction = - rtc::Optional(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(rtt_ms); + last_metrics_.rtt_ms = rtt_ms; DumpNetworkMetrics(); Controller::NetworkMetrics network_metrics; - network_metrics.rtt_ms = rtc::Optional(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(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(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(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(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& a) { - a = rtc::Optional(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(*config.uplink_packet_loss_fraction); + stats_.uplink_packet_loss_fraction = *config.uplink_packet_loss_fraction; } } - prev_config_ = rtc::Optional(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 1f0f71a543..c437918263 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 @@ TEST(AudioNetworkAdaptorImplTest, auto states = CreateAudioNetworkAdaptor(); constexpr int kBandwidth = 16000; Controller::NetworkMetrics check; - check.uplink_bandwidth_bps = rtc::Optional(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(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(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(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(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(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(32000); - config.enable_fec = rtc::Optional(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(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(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(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(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(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(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(32000); - config.enable_fec = rtc::Optional(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(32000); - config1.num_channels = rtc::Optional(2); - config1.enable_fec = rtc::Optional(true); - config1.enable_dtx = rtc::Optional(true); - config1.frame_length_ms = rtc::Optional(120); - config1.uplink_packet_loss_fraction = rtc::Optional(0.1f); - config2.bitrate_bps = rtc::Optional(16000); - config2.num_channels = rtc::Optional(1); - config2.enable_fec = rtc::Optional(false); - config2.enable_dtx = rtc::Optional(false); - config2.frame_length_ms = rtc::Optional(60); - config1.uplink_packet_loss_fraction = rtc::Optional(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 16c4bc4e55..6850926c27 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 @@ 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(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 09d10665f4..daad293af2 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 @@ void CheckDecision(BitrateController* controller, AudioEncoderRuntimeConfig config; config.frame_length_ms = frame_length_ms; controller->MakeDecision(&config); - EXPECT_EQ(rtc::Optional(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(), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps), - rtc::Optional()); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps); - network_metrics.overhead_bytes_per_packet = - rtc::Optional(kOverheadBytesPerPacket); + network_metrics.target_audio_bitrate_bps = kTargetBitrateBps; + network_metrics.overhead_bytes_per_packet = kOverheadBytesPerPacket; controller.UpdateNetworkMetrics(network_metrics); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(), 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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(), 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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(), 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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(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(kTargetBitrateBps), - rtc::Optional(kOverheadBytesPerPacket)); - CheckDecision(&controller, rtc::Optional(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( overall_bitrate - overhead_bytes_per_packet * 8 * 1000 / frame_length_ms); - UpdateNetworkMetrics(&controller, rtc::Optional(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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( overhead_bytes_per_packet * 8 * 1000 / 20 - overhead_bytes_per_packet * 8 * 1000 / 60); - UpdateNetworkMetrics(&controller, rtc::Optional(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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( overhead_bytes_per_packet * 8 * 1000 / 20 - overhead_bytes_per_packet * 8 * 1000 / 60); - UpdateNetworkMetrics(&controller, rtc::Optional(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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(overall_bitrate), - rtc::Optional(overhead_bytes_per_packet)); - CheckDecision(&controller, rtc::Optional(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 55a913a5f3..a1c30dbf3f 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 @@ void ChannelController::MakeDecision(AudioEncoderRuntimeConfig* config) { std::min(static_cast(2), config_.num_encoder_channels); } } - config->num_channels = rtc::Optional(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 73160fe224..64e5daee2b 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 @@ void CheckDecision(ChannelController* controller, } AudioEncoderRuntimeConfig config; controller->MakeDecision(&config); - EXPECT_EQ(rtc::Optional(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(), 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(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(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(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(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(kMediumBandwidthBps), 1); + CheckDecision(controller.get(), kMediumBandwidthBps, 1); // Use high bandwidth to check output switch to 2. - CheckDecision(controller.get(), rtc::Optional(kChannel1To2BandwidthBps), - 2); + CheckDecision(controller.get(), kChannel1To2BandwidthBps, 2); // Use between-thresholds bandwidth to check output remains at 2. - CheckDecision(controller.get(), rtc::Optional(kMediumBandwidthBps), 2); + CheckDecision(controller.get(), kMediumBandwidthBps, 2); // Use low bandwidth to check output switch to 1. - CheckDecision(controller.get(), rtc::Optional(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 d57396038e..313aa628c7 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 @@ ControllerManagerImpl::ControllerManagerImpl( const std::map>& scoring_points) : config_(config), controllers_(std::move(controllers)), - last_reordering_time_ms_(rtc::Optional()), + 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 ControllerManagerImpl::GetSortedControllers( if (sorted_controllers_ != sorted_controllers) { sorted_controllers_ = sorted_controllers; - last_reordering_time_ms_ = rtc::Optional(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 846397a137..576661cd35 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 @@ TEST(ControllerManagerTest, ControllersInDefaultOrderOnEmptyNetworkMetrics) { auto states = CreateControllerManager(); // |network_metrics| are empty, and the controllers are supposed to follow the // default order. - CheckControllersOrder(&states, rtc::Optional(), rtc::Optional(), + CheckControllersOrder(&states, rtc::nullopt, rtc::nullopt, {0, 1, 2, 3}); } TEST(ControllerManagerTest, ControllersWithoutCharPointAtEndAndInDefaultOrder) { auto states = CreateControllerManager(); - CheckControllersOrder(&states, rtc::Optional(0), - rtc::Optional(0.0), + CheckControllersOrder(&states, 0, + 0.0, {kNumControllers - 2, kNumControllers - 1, -1, -1}); } TEST(ControllerManagerTest, ControllersWithCharPointDependOnNetworkMetrics) { auto states = CreateControllerManager(); - CheckControllersOrder( - &states, rtc::Optional(kChracteristicBandwithBps[1]), - rtc::Optional(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(kChracteristicBandwithBps[0]), - rtc::Optional(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(kChracteristicBandwithBps[1]), - rtc::Optional(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(kBandwidthBps), - rtc::Optional(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(kBandwidthBps - kMinBandwithChangeBps - 1), - rtc::Optional(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(kBandwidthBps), - rtc::Optional(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(kBandwidthBps - kMinBandwithChangeBps + 1), - rtc::Optional(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& controllers, // initial values. switch (expected_types[i]) { case ControllerType::FEC: - EXPECT_EQ(rtc::Optional(kInitialFecEnabled), - encoder_config.enable_fec); + EXPECT_EQ(kInitialFecEnabled, encoder_config.enable_fec); break; case ControllerType::CHANNEL: - EXPECT_EQ(rtc::Optional(kIntialChannelsToEncode), - encoder_config.num_channels); + EXPECT_EQ(kIntialChannelsToEncode, encoder_config.num_channels); break; case ControllerType::DTX: - EXPECT_EQ(rtc::Optional(kInitialDtxEnabled), - encoder_config.enable_dtx); + EXPECT_EQ(kInitialDtxEnabled, encoder_config.enable_dtx); break; case ControllerType::FRAME_LENGTH: - EXPECT_EQ(rtc::Optional(kInitialFrameLengthMs), - encoder_config.frame_length_ms); + EXPECT_EQ(kInitialFrameLengthMs, encoder_config.frame_length_ms); break; case ControllerType::BIT_RATE: - EXPECT_EQ(rtc::Optional(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(kChracteristicBandwithBps[0]); - metrics.uplink_packet_loss_fraction = - rtc::Optional(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(kChracteristicBandwithBps[1]); - metrics.uplink_packet_loss_fraction = - rtc::Optional(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 7c7d6ade1a..cbfea95bd1 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 @@ void DtxController::MakeDecision(AudioEncoderRuntimeConfig* config) { dtx_enabled_ = true; } } - config->enable_dtx = rtc::Optional(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 2c58249506..e38e65d8f5 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 @@ void CheckDecision(DtxController* controller, } AudioEncoderRuntimeConfig config; controller->MakeDecision(&config); - EXPECT_EQ(rtc::Optional(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(), kInitialDtxEnabled); + CheckDecision(controller.get(), rtc::nullopt, kInitialDtxEnabled); } TEST(DtxControllerTest, TurnOnDtxForLowUplinkBandwidth) { auto controller = CreateController(false); - CheckDecision(controller.get(), rtc::Optional(kDtxEnablingBandwidthBps), - true); + CheckDecision(controller.get(), kDtxEnablingBandwidthBps, true); } TEST(DtxControllerTest, TurnOffDtxForHighUplinkBandwidth) { auto controller = CreateController(true); - CheckDecision(controller.get(), rtc::Optional(kDtxDisablingBandwidthBps), - false); + CheckDecision(controller.get(), kDtxDisablingBandwidthBps, false); } TEST(DtxControllerTest, MaintainDtxOffForMediumUplinkBandwidth) { auto controller = CreateController(false); - CheckDecision(controller.get(), rtc::Optional(kMediumBandwidthBps), - false); + CheckDecision(controller.get(), kMediumBandwidthBps, false); } TEST(DtxControllerTest, MaintainDtxOnForMediumUplinkBandwidth) { auto controller = CreateController(true); - CheckDecision(controller.get(), rtc::Optional(kMediumBandwidthBps), - true); + CheckDecision(controller.get(), kMediumBandwidthBps, true); } TEST(DtxControllerTest, CheckBehaviorOnChangingUplinkBandwidth) { auto controller = CreateController(false); - CheckDecision(controller.get(), rtc::Optional(kMediumBandwidthBps), - false); - CheckDecision(controller.get(), rtc::Optional(kDtxEnablingBandwidthBps), - true); - CheckDecision(controller.get(), rtc::Optional(kMediumBandwidthBps), - true); - CheckDecision(controller.get(), rtc::Optional(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 ee8249a1ed..df975947ca 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 @@ EventLogWriterStates CreateEventLogWriter() { state.event_log_writer.reset(new EventLogWriter( state.event_log.get(), kMinBitrateChangeBps, kMinBitrateChangeFraction, kMinPacketLossChangeFraction)); - state.runtime_config.bitrate_bps = rtc::Optional(kHighBitrateBps); - state.runtime_config.frame_length_ms = rtc::Optional(kFrameLengthMs); - state.runtime_config.uplink_packet_loss_fraction = - rtc::Optional(kPacketLossFraction); - state.runtime_config.enable_fec = rtc::Optional(kEnableFec); - state.runtime_config.enable_dtx = rtc::Optional(kEnableDtx); - state.runtime_config.num_channels = rtc::Optional(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(!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(!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(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(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(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(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(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( - 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( + 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( - 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( - kPacketLossFraction + kMinPacketLossChangeFraction * kPacketLossFraction); - state.runtime_config.frame_length_ms = rtc::Optional(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(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(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 80cc695342..62f356dd07 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 webrtc { namespace { class NullSmoothingFilter final : public SmoothingFilter { public: - void AddSample(float sample) override { - last_sample_ = rtc::Optional(sample); - } + void AddSample(float sample) override { last_sample_ = sample; } rtc::Optional 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(fec_enabled_); + config->enable_fec = fec_enabled_; - config->uplink_packet_loss_fraction = - rtc::Optional(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 41d959d482..8636aa96b1 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 @@ 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(*uplink_packet_loss))); + .WillOnce(Return(*uplink_packet_loss)); } } -void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states, - int uplink_bandwidth_bps, - float uplink_packet_loss) { - UpdateNetworkMetrics(states, rtc::Optional(uplink_bandwidth_bps), - rtc::Optional(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(expected_enable_fec), config.enable_fec); - EXPECT_EQ(rtc::Optional(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(), - rtc::Optional(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(bandwidth), - rtc::Optional()); + 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(kEnablingBandwidthHigh); - network_metrics.uplink_packet_loss_fraction = - rtc::Optional(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(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 eb56ea0dee..c8cfd31607 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 @@ void FecControllerRplrBased::MakeDecision(AudioEncoderRuntimeConfig* config) { fec_enabled_ = fec_enabled_ ? !FecDisablingDecision() : FecEnablingDecision(); - config->enable_fec = rtc::Optional(fec_enabled_); - config->uplink_packet_loss_fraction = rtc::Optional( - 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 f20122fd2c..0fc003beab 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 @@ rtc::Optional GetRandomProbabilityOrUnknown() { std::mt19937 generator(rd()); std::uniform_real_distribution<> distribution(0, 1); - if (distribution(generator) < 0.2) { - return rtc::Optional(); - } else { - return rtc::Optional(distribution(generator)); - } + return (distribution(generator) < 0.2) + ? rtc::nullopt + : rtc::Optional(distribution(generator)); } std::unique_ptr 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(uplink_bandwidth_bps), - rtc::Optional(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(), - rtc::Optional(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(bandwidth), - rtc::Optional()); + 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(kEnablingBandwidthHigh); - network_metrics.uplink_packet_loss_fraction = - rtc::Optional(GetRandomProbabilityOrUnknown()); + network_metrics.uplink_bandwidth_bps = kEnablingBandwidthHigh; + network_metrics.uplink_packet_loss_fraction = GetRandomProbabilityOrUnknown(); network_metrics.uplink_recoverable_packet_loss_fraction = - rtc::Optional(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 5ae78b031c..6c3cae07bc 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 @@ void FrameLengthController::MakeDecision(AudioEncoderRuntimeConfig* config) { prev_decision_increase_ = false; } config->last_fl_change_increase = prev_decision_increase_; - config->frame_length_ms = rtc::Optional(*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 4c96c96f6f..1f984470c0 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 @@ void CheckDecision(FrameLengthController* controller, int expected_frame_length_ms) { AudioEncoderRuntimeConfig config; controller->MakeDecision(&config); - EXPECT_EQ(rtc::Optional(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(kFl60msTo20msBandwidthBps), - rtc::Optional(), rtc::Optional(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(), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(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(kMediumBandwidthBps), - rtc::Optional(kMediumPacketLossFraction), - rtc::Optional(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(kFl20msTo60msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(VeryLowBitrate(20)), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(VeryLowBitrate(20)), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kFl20msTo60msBandwidthBps); - network_metrics.uplink_packet_loss_fraction = - rtc::Optional(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(kFl20msTo60msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kMediumBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kFl20msTo60msBandwidthBps), - rtc::Optional(kMediumPacketLossFraction), - rtc::Optional(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(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kFl60msTo20msBandwidthBps), - rtc::Optional(), rtc::Optional(kOverheadBytesPerPacket)); + UpdateNetworkMetrics(controller.get(), + kFl60msTo20msBandwidthBps, + rtc::nullopt, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); - UpdateNetworkMetrics( - controller.get(), rtc::Optional(kFl60msTo20msBandwidthBps), - rtc::Optional(), rtc::Optional(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(), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + UpdateNetworkMetrics(controller.get(), rtc::nullopt, + kFlDecreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); - UpdateNetworkMetrics(controller.get(), rtc::Optional(), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(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(VeryLowBitrate(60)), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(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(VeryLowBitrate(60)), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(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(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl60msTo120msBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl60msTo120msBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(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(kMediumBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kMediumBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 20); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl20msTo60msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl20msTo60msBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl60msTo120msBandwidthBps), - rtc::Optional(kMediumPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl60msTo120msBandwidthBps, + kMediumPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl60msTo120msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl60msTo120msBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 120); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kFl120msTo60msBandwidthBps), - rtc::Optional(kFlIncreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kFl120msTo60msBandwidthBps, + kFlIncreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 60); UpdateNetworkMetrics(controller.get(), - rtc::Optional(kMediumBandwidthBps), - rtc::Optional(kFlDecreasingPacketLossFraction), - rtc::Optional(kOverheadBytesPerPacket)); + kMediumBandwidthBps, + kFlDecreasingPacketLossFraction, + kOverheadBytesPerPacket); CheckDecision(controller.get(), 20); } diff --git a/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc b/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc index 577962548d..303529e3c7 100644 --- a/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc +++ b/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc @@ -222,7 +222,7 @@ TEST_F(AudioEncoderCngTest, CheckTargetAudioBitratePropagation) { CreateCng(MakeCngConfig()); EXPECT_CALL(*mock_encoder_, OnReceivedUplinkBandwidth(4711, rtc::Optional())); - cng_->OnReceivedUplinkBandwidth(4711, rtc::Optional()); + cng_->OnReceivedUplinkBandwidth(4711, rtc::nullopt); } TEST_F(AudioEncoderCngTest, CheckPacketLossFractionPropagation) { diff --git a/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc b/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc index 8c35b647b4..341336ee14 100644 --- a/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc +++ b/modules/audio_coding/codecs/legacy_encoded_audio_frame.cc @@ -35,9 +35,9 @@ LegacyEncodedAudioFrame::Decode(rtc::ArrayView decoded) const { decoded.size() * sizeof(int16_t), decoded.data(), &speech_type); if (ret < 0) - return rtc::Optional(); + return rtc::nullopt; - return rtc::Optional({static_cast(ret), speech_type}); + return DecodeResult{static_cast(ret), speech_type}; } std::vector LegacyEncodedAudioFrame::SplitBySamples( diff --git a/modules/audio_coding/codecs/opus/audio_decoder_opus.cc b/modules/audio_coding/codecs/opus/audio_decoder_opus.cc index a48c7dbdde..3d10b6fdbe 100644 --- a/modules/audio_coding/codecs/opus/audio_decoder_opus.cc +++ b/modules/audio_coding/codecs/opus/audio_decoder_opus.cc @@ -51,9 +51,9 @@ class OpusFrame : public AudioDecoder::EncodedAudioFrame { } if (ret < 0) - return rtc::Optional(); + return rtc::nullopt; - return rtc::Optional({static_cast(ret), speech_type}); + return DecodeResult{static_cast(ret), speech_type}; } private: diff --git a/modules/audio_coding/codecs/opus/audio_encoder_opus.cc b/modules/audio_coding/codecs/opus/audio_encoder_opus.cc index d5358bb2aa..5a5ac34c5c 100644 --- a/modules/audio_coding/codecs/opus/audio_encoder_opus.cc +++ b/modules/audio_coding/codecs/opus/audio_encoder_opus.cc @@ -108,9 +108,10 @@ float OptimizePacketLossRate(float new_loss_rate, float old_loss_rate) { rtc::Optional GetFormatParameter(const SdpAudioFormat& format, const std::string& param) { auto it = format.parameters.find(param); - return (it == format.parameters.end()) - ? rtc::Optional() - : rtc::Optional(it->second); + if (it == format.parameters.end()) + return rtc::nullopt; + + return it->second; } template @@ -255,9 +256,9 @@ rtc::Optional AudioEncoderOpusImpl::QueryAudioEncoder( info.allow_comfort_noise = false; info.supports_network_adaption = true; - return rtc::Optional(info); + return info; } - return rtc::Optional(); + return rtc::nullopt; } AudioEncoderOpusConfig AudioEncoderOpusImpl::CreateConfig( @@ -265,7 +266,7 @@ AudioEncoderOpusConfig AudioEncoderOpusImpl::CreateConfig( AudioEncoderOpusConfig config; config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48); config.num_channels = codec_inst.channels; - config.bitrate_bps = rtc::Optional(codec_inst.rate); + config.bitrate_bps = codec_inst.rate; config.application = config.num_channels == 1 ? AudioEncoderOpusConfig::ApplicationMode::kVoip : AudioEncoderOpusConfig::ApplicationMode::kAudio; @@ -277,7 +278,7 @@ rtc::Optional AudioEncoderOpusImpl::SdpToConfig( const SdpAudioFormat& format) { if (STR_CASE_CMP(format.name.c_str(), "opus") != 0 || format.clockrate_hz != 48000 || format.num_channels != 2) { - return rtc::Optional(); + return rtc::nullopt; } AudioEncoderOpusConfig config; @@ -287,9 +288,9 @@ rtc::Optional AudioEncoderOpusImpl::SdpToConfig( config.fec_enabled = (GetFormatParameter(format, "useinbandfec") == "1"); config.dtx_enabled = (GetFormatParameter(format, "usedtx") == "1"); config.cbr_enabled = (GetFormatParameter(format, "cbr") == "1"); - config.bitrate_bps = rtc::Optional( + config.bitrate_bps = CalculateBitrate(config.max_playback_rate_hz, config.num_channels, - GetFormatParameter(format, "maxaveragebitrate"))); + GetFormatParameter(format, "maxaveragebitrate")); config.application = config.num_channels == 1 ? AudioEncoderOpusConfig::ApplicationMode::kVoip : AudioEncoderOpusConfig::ApplicationMode::kAudio; @@ -309,7 +310,7 @@ rtc::Optional AudioEncoderOpusImpl::SdpToConfig( FindSupportedFrameLengths(min_frame_length_ms, max_frame_length_ms, &config.supported_frame_lengths_ms); RTC_DCHECK(config.IsOk()); - return rtc::Optional(config); + return config; } rtc::Optional AudioEncoderOpusImpl::GetNewComplexity( @@ -321,11 +322,11 @@ rtc::Optional AudioEncoderOpusImpl::GetNewComplexity( bitrate_bps <= config.complexity_threshold_bps + config.complexity_threshold_window_bps) { // Within the hysteresis window; make no change. - return rtc::Optional(); + return rtc::nullopt; } else { - return rtc::Optional(bitrate_bps <= config.complexity_threshold_bps - ? config.low_rate_complexity - : config.complexity); + return bitrate_bps <= config.complexity_threshold_bps + ? config.low_rate_complexity + : config.complexity; } } @@ -552,8 +553,7 @@ void AudioEncoderOpusImpl::OnReceivedOverhead( audio_network_adaptor_->SetOverhead(overhead_bytes_per_packet); ApplyAudioNetworkAdaptor(); } else { - overhead_bytes_per_packet_ = - rtc::Optional(overhead_bytes_per_packet); + overhead_bytes_per_packet_ = overhead_bytes_per_packet; } } @@ -707,9 +707,9 @@ void AudioEncoderOpusImpl::SetProjectedPacketLossRate(float fraction) { } void AudioEncoderOpusImpl::SetTargetBitrate(int bits_per_second) { - config_.bitrate_bps = rtc::Optional(rtc::SafeClamp( + config_.bitrate_bps = rtc::SafeClamp( bits_per_second, AudioEncoderOpusConfig::kMinBitrateBps, - AudioEncoderOpusConfig::kMaxBitrateBps)); + AudioEncoderOpusConfig::kMaxBitrateBps); RTC_DCHECK(config_.IsOk()); RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, GetBitrateBps(config_))); const auto new_complexity = GetNewComplexity(config_); @@ -759,7 +759,7 @@ void AudioEncoderOpusImpl::MaybeUpdateUplinkBandwidth() { rtc::Optional smoothed_bitrate = bitrate_smoother_->GetAverage(); if (smoothed_bitrate) audio_network_adaptor_->SetUplinkBandwidth(*smoothed_bitrate); - bitrate_smoother_last_update_time_ = rtc::Optional(now_ms); + bitrate_smoother_last_update_time_ = now_ms; } } } diff --git a/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc b/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc index 5a83a4bd74..868de8caa2 100644 --- a/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc +++ b/modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc @@ -38,7 +38,7 @@ AudioEncoderOpusConfig CreateConfig(const CodecInst& codec_inst) { AudioEncoderOpusConfig config; config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48); config.num_channels = codec_inst.channels; - config.bitrate_bps = rtc::Optional(codec_inst.rate); + config.bitrate_bps = codec_inst.rate; config.application = config.num_channels == 1 ? AudioEncoderOpusConfig::ApplicationMode::kVoip : AudioEncoderOpusConfig::ApplicationMode::kAudio; @@ -102,13 +102,12 @@ AudioEncoderRuntimeConfig CreateEncoderRuntimeConfig() { constexpr size_t kNumChannels = 1; constexpr float kPacketLossFraction = 0.1f; AudioEncoderRuntimeConfig config; - config.bitrate_bps = rtc::Optional(kBitrate); - config.frame_length_ms = rtc::Optional(kFrameLength); - config.enable_fec = rtc::Optional(kEnableFec); - config.enable_dtx = rtc::Optional(kEnableDtx); - config.num_channels = rtc::Optional(kNumChannels); - config.uplink_packet_loss_fraction = - rtc::Optional(kPacketLossFraction); + config.bitrate_bps = kBitrate; + config.frame_length_ms = kFrameLength; + config.enable_fec = kEnableFec; + config.enable_dtx = kEnableDtx; + config.num_channels = kNumChannels; + config.uplink_packet_loss_fraction = kPacketLossFraction; return config; } @@ -201,24 +200,20 @@ TEST(AudioEncoderOpusTest, const int kMinBitrateBps = 6000; const int kMaxBitrateBps = 510000; // Set a too low bitrate. - states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps - 1, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps - 1, rtc::nullopt); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set a too high bitrate. - states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1, rtc::nullopt); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); // Set the minimum rate. - states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps, rtc::nullopt); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set the maximum rate. - states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps, rtc::nullopt); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); // Set rates from kMaxBitrateBps up to 32000 bps. for (int rate = kMinBitrateBps; rate <= 32000; rate += 1000) { - states.encoder->OnReceivedUplinkBandwidth(rate, rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(rate, rtc::nullopt); EXPECT_EQ(rate, states.encoder->GetTargetBitrate()); } } @@ -329,8 +324,8 @@ TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) { EXPECT_CALL(*states.mock_bitrate_smoother, SetTimeConstantMs(kProbingIntervalMs * 4)); EXPECT_CALL(*states.mock_bitrate_smoother, AddSample(kTargetAudioBitrate)); - states.encoder->OnReceivedUplinkBandwidth( - kTargetAudioBitrate, rtc::Optional(kProbingIntervalMs)); + states.encoder->OnReceivedUplinkBandwidth(kTargetAudioBitrate, + kProbingIntervalMs); CheckEncoderRuntimeConfig(states.encoder.get(), config); } @@ -401,7 +396,7 @@ TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) { auto states = CreateCodec(2); states.encoder->OnReceivedUplinkBandwidth(kDefaultOpusSettings.rate * 2, - rtc::Optional()); + rtc::nullopt); // Since |OnReceivedOverhead| has not been called, the codec bitrate should // not change. @@ -418,8 +413,7 @@ TEST(AudioEncoderOpusTest, OverheadRemovedFromTargetAudioBitrate) { states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket); constexpr int kTargetBitrateBps = 40000; - states.encoder->OnReceivedUplinkBandwidth(kTargetBitrateBps, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(kTargetBitrateBps, rtc::nullopt); int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize); EXPECT_EQ(kTargetBitrateBps - @@ -445,16 +439,14 @@ TEST(AudioEncoderOpusTest, BitrateBounded) { // subtracted. The eventual codec rate should be bounded by |kMinBitrateBps|. int target_bitrate = kOverheadBytesPerPacket * 8 * packet_rate + kMinBitrateBps - 1; - states.encoder->OnReceivedUplinkBandwidth(target_bitrate, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(target_bitrate, rtc::nullopt); EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate()); // Set a target rate that is greater than |kMaxBitrateBps| when overhead is // subtracted. The eventual codec rate should be bounded by |kMaxBitrateBps|. target_bitrate = kOverheadBytesPerPacket * 8 * packet_rate + kMaxBitrateBps + 1; - states.encoder->OnReceivedUplinkBandwidth(target_bitrate, - rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(target_bitrate, rtc::nullopt); EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate()); } @@ -465,24 +457,20 @@ TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) { config.complexity = 6; // Bitrate within hysteresis window. Expect empty output. - config.bitrate_bps = rtc::Optional(12500); - EXPECT_EQ(rtc::Optional(), - AudioEncoderOpusImpl::GetNewComplexity(config)); + config.bitrate_bps = 12500; + EXPECT_EQ(rtc::nullopt, AudioEncoderOpusImpl::GetNewComplexity(config)); // Bitrate below hysteresis window. Expect higher complexity. - config.bitrate_bps = rtc::Optional(10999); - EXPECT_EQ(rtc::Optional(8), - AudioEncoderOpusImpl::GetNewComplexity(config)); + config.bitrate_bps = 10999; + EXPECT_EQ(8, AudioEncoderOpusImpl::GetNewComplexity(config)); // Bitrate within hysteresis window. Expect empty output. - config.bitrate_bps = rtc::Optional(12500); - EXPECT_EQ(rtc::Optional(), - AudioEncoderOpusImpl::GetNewComplexity(config)); + config.bitrate_bps = 12500; + EXPECT_EQ(rtc::nullopt, AudioEncoderOpusImpl::GetNewComplexity(config)); // Bitrate above hysteresis window. Expect lower complexity. - config.bitrate_bps = rtc::Optional(14001); - EXPECT_EQ(rtc::Optional(6), - AudioEncoderOpusImpl::GetNewComplexity(config)); + config.bitrate_bps = 14001; + EXPECT_EQ(6, AudioEncoderOpusImpl::GetNewComplexity(config)); } TEST(AudioEncoderOpusTest, EmptyConfigDoesNotAffectEncoderSettings) { @@ -512,7 +500,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) { audio.fill(0); rtc::Buffer encoded; EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) - .WillOnce(Return(rtc::Optional(50000))); + .WillOnce(Return(50000)); EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000)); states.encoder->Encode( 0, rtc::ArrayView(audio.data(), audio.size()), &encoded); @@ -527,7 +515,7 @@ TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) { // Update when it is time to update. EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage()) - .WillOnce(Return(rtc::Optional(40000))); + .WillOnce(Return(40000)); EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000)); states.fake_clock->AdvanceTime(rtc::TimeDelta::FromMilliseconds(1)); states.encoder->Encode( @@ -544,7 +532,7 @@ TEST(AudioEncoderOpusTest, EncodeAtMinBitrate) { rtc::Buffer encoded; uint32_t rtp_timestamp = 12345; // Just a number not important to this test. - states.encoder->OnReceivedUplinkBandwidth(0, rtc::Optional()); + states.encoder->OnReceivedUplinkBandwidth(0, rtc::nullopt); for (int packet_index = 0; packet_index < kNumPacketsToEncode; packet_index++) { // Make sure we are not encoding before we have enough data for diff --git a/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc b/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc index 6d9e911ed9..4c9174d92c 100644 --- a/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc +++ b/modules/audio_coding/codecs/opus/opus_complexity_unittest.cc @@ -64,11 +64,11 @@ TEST(AudioEncoderOpusComplexityAdaptationTest, AdaptationOn) { AudioEncoderOpusConfig config; // The limit -- including the hysteresis window -- at which the complexity // shuold be increased. - config.bitrate_bps = rtc::Optional(11000 - 1); + config.bitrate_bps = 11000 - 1; config.low_rate_complexity = 9; int64_t runtime_10999bps = RunComplexityTest(config); - config.bitrate_bps = rtc::Optional(15500); + config.bitrate_bps = 15500; int64_t runtime_15500bps = RunComplexityTest(config); test::PrintResult("opus_encoding_complexity_ratio", "", "adaptation_on", @@ -85,10 +85,10 @@ TEST(AudioEncoderOpusComplexityAdaptationTest, AdaptationOff) { // The limit -- including the hysteresis window -- at which the complexity // shuold be increased (but not in this test since complexity adaptation is // disabled). - config.bitrate_bps = rtc::Optional(11000 - 1); + config.bitrate_bps = 11000 - 1; int64_t runtime_10999bps = RunComplexityTest(config); - config.bitrate_bps = rtc::Optional(15500); + config.bitrate_bps = 15500; int64_t runtime_15500bps = RunComplexityTest(config); test::PrintResult("opus_encoding_complexity_ratio", "", "adaptation_off", diff --git a/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc b/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc index 8409b82fea..8c63796525 100644 --- a/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc +++ b/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc @@ -101,7 +101,7 @@ TEST_F(AudioEncoderCopyRedTest, CheckMaxFrameSizePropagation) { TEST_F(AudioEncoderCopyRedTest, CheckTargetAudioBitratePropagation) { EXPECT_CALL(*mock_encoder_, OnReceivedUplinkBandwidth(4711, rtc::Optional())); - red_->OnReceivedUplinkBandwidth(4711, rtc::Optional()); + red_->OnReceivedUplinkBandwidth(4711, rtc::nullopt); } TEST_F(AudioEncoderCopyRedTest, CheckPacketLossFractionPropagation) { diff --git a/modules/audio_coding/neteq/audio_decoder_unittest.cc b/modules/audio_coding/neteq/audio_decoder_unittest.cc index ae164fd55f..3181d6fc1c 100644 --- a/modules/audio_coding/neteq/audio_decoder_unittest.cc +++ b/modules/audio_coding/neteq/audio_decoder_unittest.cc @@ -462,7 +462,7 @@ TEST_F(AudioDecoderPcmUTest, EncodeDecode) { namespace { int SetAndGetTargetBitrate(AudioEncoder* audio_encoder, int rate) { - audio_encoder->OnReceivedUplinkBandwidth(rate, rtc::Optional()); + audio_encoder->OnReceivedUplinkBandwidth(rate, rtc::nullopt); return audio_encoder->GetTargetBitrate(); } void TestSetAndGetTargetBitratesWithFixedCodec(AudioEncoder* audio_encoder, diff --git a/modules/audio_coding/neteq/decoder_database.cc b/modules/audio_coding/neteq/decoder_database.cc index 743ca8775e..d289b45cc0 100644 --- a/modules/audio_coding/neteq/decoder_database.cc +++ b/modules/audio_coding/neteq/decoder_database.cc @@ -104,10 +104,9 @@ DecoderDatabase::DecoderInfo::CngDecoder::Create(const SdpAudioFormat& format) { const int sample_rate_hz = format.clockrate_hz; RTC_DCHECK(sample_rate_hz == 8000 || sample_rate_hz == 16000 || sample_rate_hz == 32000 || sample_rate_hz == 48000); - return rtc::Optional( - {sample_rate_hz}); + return DecoderDatabase::DecoderInfo::CngDecoder{sample_rate_hz}; } else { - return rtc::Optional(); + return rtc::nullopt; } } diff --git a/modules/audio_coding/neteq/neteq_decoder_enum.cc b/modules/audio_coding/neteq/neteq_decoder_enum.cc index 2c61b0afdf..8d66c2a25c 100644 --- a/modules/audio_coding/neteq/neteq_decoder_enum.cc +++ b/modules/audio_coding/neteq/neteq_decoder_enum.cc @@ -18,71 +18,67 @@ namespace webrtc { rtc::Optional NetEqDecoderToSdpAudioFormat(NetEqDecoder nd) { switch (nd) { case NetEqDecoder::kDecoderPCMu: - return rtc::Optional(SdpAudioFormat("pcmu", 8000, 1)); + return SdpAudioFormat("pcmu", 8000, 1); case NetEqDecoder::kDecoderPCMa: - return rtc::Optional(SdpAudioFormat("pcma", 8000, 1)); + return SdpAudioFormat("pcma", 8000, 1); case NetEqDecoder::kDecoderPCMu_2ch: - return rtc::Optional(SdpAudioFormat("pcmu", 8000, 2)); + return SdpAudioFormat("pcmu", 8000, 2); case NetEqDecoder::kDecoderPCMa_2ch: - return rtc::Optional(SdpAudioFormat("pcma", 8000, 2)); + return SdpAudioFormat("pcma", 8000, 2); case NetEqDecoder::kDecoderILBC: - return rtc::Optional(SdpAudioFormat("ilbc", 8000, 1)); + return SdpAudioFormat("ilbc", 8000, 1); case NetEqDecoder::kDecoderISAC: - return rtc::Optional(SdpAudioFormat("isac", 16000, 1)); + return SdpAudioFormat("isac", 16000, 1); case NetEqDecoder::kDecoderISACswb: - return rtc::Optional(SdpAudioFormat("isac", 32000, 1)); + return SdpAudioFormat("isac", 32000, 1); case NetEqDecoder::kDecoderPCM16B: - return rtc::Optional(SdpAudioFormat("l16", 8000, 1)); + return SdpAudioFormat("l16", 8000, 1); case NetEqDecoder::kDecoderPCM16Bwb: - return rtc::Optional(SdpAudioFormat("l16", 16000, 1)); + return SdpAudioFormat("l16", 16000, 1); case NetEqDecoder::kDecoderPCM16Bswb32kHz: - return rtc::Optional(SdpAudioFormat("l16", 32000, 1)); + return SdpAudioFormat("l16", 32000, 1); case NetEqDecoder::kDecoderPCM16Bswb48kHz: - return rtc::Optional(SdpAudioFormat("l16", 48000, 1)); + return SdpAudioFormat("l16", 48000, 1); case NetEqDecoder::kDecoderPCM16B_2ch: - return rtc::Optional(SdpAudioFormat("l16", 8000, 2)); + return SdpAudioFormat("l16", 8000, 2); case NetEqDecoder::kDecoderPCM16Bwb_2ch: - return rtc::Optional(SdpAudioFormat("l16", 16000, 2)); + return SdpAudioFormat("l16", 16000, 2); case NetEqDecoder::kDecoderPCM16Bswb32kHz_2ch: - return rtc::Optional(SdpAudioFormat("l16", 32000, 2)); + return SdpAudioFormat("l16", 32000, 2); case NetEqDecoder::kDecoderPCM16Bswb48kHz_2ch: - return rtc::Optional(SdpAudioFormat("l16", 48000, 2)); + return SdpAudioFormat("l16", 48000, 2); case NetEqDecoder::kDecoderPCM16B_5ch: - return rtc::Optional(SdpAudioFormat("l16", 8000, 5)); + return SdpAudioFormat("l16", 8000, 5); case NetEqDecoder::kDecoderG722: - return rtc::Optional(SdpAudioFormat("g722", 8000, 1)); + return SdpAudioFormat("g722", 8000, 1); case NetEqDecoder::kDecoderG722_2ch: - return rtc::Optional(SdpAudioFormat("g722", 8000, 2)); + return SdpAudioFormat("g722", 8000, 2); case NetEqDecoder::kDecoderOpus: - return rtc::Optional(SdpAudioFormat("opus", 48000, 2)); + return SdpAudioFormat("opus", 48000, 2); case NetEqDecoder::kDecoderOpus_2ch: - return rtc::Optional( - SdpAudioFormat("opus", 48000, 2, - std::map{{"stereo", "1"}})); + return SdpAudioFormat( + "opus", 48000, 2, + std::map{{"stereo", "1"}}); case NetEqDecoder::kDecoderRED: - return rtc::Optional(SdpAudioFormat("red", 8000, 1)); + return SdpAudioFormat("red", 8000, 1); case NetEqDecoder::kDecoderAVT: - return rtc::Optional( - SdpAudioFormat("telephone-event", 8000, 1)); + return SdpAudioFormat("telephone-event", 8000, 1); case NetEqDecoder::kDecoderAVT16kHz: - return rtc::Optional( - SdpAudioFormat("telephone-event", 16000, 1)); + return SdpAudioFormat("telephone-event", 16000, 1); case NetEqDecoder::kDecoderAVT32kHz: - return rtc::Optional( - SdpAudioFormat("telephone-event", 32000, 1)); + return SdpAudioFormat("telephone-event", 32000, 1); case NetEqDecoder::kDecoderAVT48kHz: - return rtc::Optional( - SdpAudioFormat("telephone-event", 48000, 1)); + return SdpAudioFormat("telephone-event", 48000, 1); case NetEqDecoder::kDecoderCNGnb: - return rtc::Optional(SdpAudioFormat("cn", 8000, 1)); + return SdpAudioFormat("cn", 8000, 1); case NetEqDecoder::kDecoderCNGwb: - return rtc::Optional(SdpAudioFormat("cn", 16000, 1)); + return SdpAudioFormat("cn", 16000, 1); case NetEqDecoder::kDecoderCNGswb32kHz: - return rtc::Optional(SdpAudioFormat("cn", 32000, 1)); + return SdpAudioFormat("cn", 32000, 1); case NetEqDecoder::kDecoderCNGswb48kHz: - return rtc::Optional(SdpAudioFormat("cn", 48000, 1)); + return SdpAudioFormat("cn", 48000, 1); default: - return rtc::Optional(); + return rtc::nullopt; } } diff --git a/modules/audio_coding/neteq/neteq_impl.cc b/modules/audio_coding/neteq/neteq_impl.cc index 089f6caf9c..14f2fc7aaa 100644 --- a/modules/audio_coding/neteq/neteq_impl.cc +++ b/modules/audio_coding/neteq/neteq_impl.cc @@ -423,10 +423,9 @@ rtc::Optional NetEqImpl::GetPlayoutTimestamp() const { // We don't have a valid RTP timestamp until we have decoded our first // RTP packet. Also, the RTP timestamp is not accurate while playing CNG, // which is indicated by returning an empty value. - return rtc::Optional(); + return rtc::nullopt; } - return rtc::Optional( - timestamp_scaler_->ToExternal(playout_timestamp_)); + return timestamp_scaler_->ToExternal(playout_timestamp_); } int NetEqImpl::last_output_sample_rate_hz() const { @@ -439,7 +438,7 @@ rtc::Optional NetEqImpl::GetDecoder(int payload_type) const { const DecoderDatabase::DecoderInfo* di = decoder_database_->GetDecoderInfo(payload_type); if (!di) { - return rtc::Optional(); + return rtc::nullopt; } // Create a CodecInst with some fields set. The remaining fields are zeroed, @@ -452,7 +451,7 @@ rtc::Optional NetEqImpl::GetDecoder(int payload_type) const { ci.plfreq = di->IsRed() ? 8000 : di->SampleRateHz(); AudioDecoder* const decoder = di->GetDecoder(); ci.channels = decoder ? decoder->Channels() : 1; - return rtc::Optional(ci); + return ci; } rtc::Optional NetEqImpl::GetDecoderFormat( @@ -461,9 +460,9 @@ rtc::Optional NetEqImpl::GetDecoderFormat( const DecoderDatabase::DecoderInfo* const di = decoder_database_->GetDecoderInfo(payload_type); if (!di) { - return rtc::Optional(); // Payload type not registered. + return rtc::nullopt; // Payload type not registered. } - return rtc::Optional(di->GetFormat()); + return di->GetFormat(); } int NetEqImpl::SetTargetNumberOfChannels() { @@ -2004,7 +2003,7 @@ int NetEqImpl::ExtractPackets(size_t required_samples, stats_.JitterBufferDelay(extracted_samples, waiting_time_ms); packet_list->push_back(std::move(*packet)); // Store packet in list. - packet = rtc::Optional(); // Ensure it's never used after the move. + packet = rtc::nullopt; // Ensure it's never used after the move. // Check what packet is available next. next_packet = packet_buffer_->PeekNextPacket(); diff --git a/modules/audio_coding/neteq/neteq_impl_unittest.cc b/modules/audio_coding/neteq/neteq_impl_unittest.cc index cade064e2c..2a21e51b38 100644 --- a/modules/audio_coding/neteq/neteq_impl_unittest.cc +++ b/modules/audio_coding/neteq/neteq_impl_unittest.cc @@ -348,9 +348,8 @@ TEST_F(NetEqImplTest, InsertPacket) { .Times(1); EXPECT_CALL(*mock_packet_buffer_, InsertPacketList(_, _, _, _, _)) .Times(2) - .WillRepeatedly( - DoAll(SetArgPointee<2>(rtc::Optional(kPayloadType)), - WithArg<0>(Invoke(DeletePacketsAndReturnOk)))); + .WillRepeatedly(DoAll(SetArgPointee<2>(kPayloadType), + WithArg<0>(Invoke(DeletePacketsAndReturnOk)))); // SetArgPointee<2>(kPayloadType) means that the third argument (zero-based // index) is a pointer, and the variable pointed to is set to kPayloadType. // Also invoke the function DeletePacketsAndReturnOk to properly delete all diff --git a/modules/audio_coding/neteq/neteq_network_stats_unittest.cc b/modules/audio_coding/neteq/neteq_network_stats_unittest.cc index 1173da2624..334715f8d1 100644 --- a/modules/audio_coding/neteq/neteq_network_stats_unittest.cc +++ b/modules/audio_coding/neteq/neteq_network_stats_unittest.cc @@ -53,12 +53,11 @@ class MockAudioDecoder final : public AudioDecoder { if (decoded.size() >= output_size) { memset(decoded.data(), 0, sizeof(int16_t) * kPacketDuration * num_channels_); - return rtc::Optional( - {kPacketDuration * num_channels_, kSpeech}); + return DecodeResult{kPacketDuration * num_channels_, kSpeech}; } else { ADD_FAILURE() << "Expected decoded.size() to be >= output_size (" << decoded.size() << " vs. " << output_size << ")"; - return rtc::Optional(); + return rtc::nullopt; } } diff --git a/modules/audio_coding/neteq/packet_buffer.cc b/modules/audio_coding/neteq/packet_buffer.cc index 3005d43aad..dfffebdae6 100644 --- a/modules/audio_coding/neteq/packet_buffer.cc +++ b/modules/audio_coding/neteq/packet_buffer.cc @@ -139,12 +139,11 @@ int PacketBuffer::InsertPacketList( if (*current_cng_rtp_payload_type && **current_cng_rtp_payload_type != packet.payload_type) { // New CNG payload type implies new codec type. - *current_rtp_payload_type = rtc::Optional(); + *current_rtp_payload_type = rtc::nullopt; Flush(); flushed = true; } - *current_cng_rtp_payload_type = - rtc::Optional(packet.payload_type); + *current_cng_rtp_payload_type = packet.payload_type; } else if (!decoder_database.IsDtmf(packet.payload_type)) { // This must be speech. if ((*current_rtp_payload_type && @@ -153,11 +152,11 @@ int PacketBuffer::InsertPacketList( !EqualSampleRates(packet.payload_type, **current_cng_rtp_payload_type, decoder_database))) { - *current_cng_rtp_payload_type = rtc::Optional(); + *current_cng_rtp_payload_type = rtc::nullopt; Flush(); flushed = true; } - *current_rtp_payload_type = rtc::Optional(packet.payload_type); + *current_rtp_payload_type = packet.payload_type; } int return_val = InsertPacket(std::move(packet), stats); if (return_val == kFlushed) { @@ -210,7 +209,7 @@ const Packet* PacketBuffer::PeekNextPacket() const { rtc::Optional PacketBuffer::GetNextPacket() { if (Empty()) { // Buffer is empty. - return rtc::Optional(); + return rtc::nullopt; } rtc::Optional packet(std::move(buffer_.front())); diff --git a/modules/audio_coding/neteq/packet_buffer_unittest.cc b/modules/audio_coding/neteq/packet_buffer_unittest.cc index 4beead6729..0ddeb8a585 100644 --- a/modules/audio_coding/neteq/packet_buffer_unittest.cc +++ b/modules/audio_coding/neteq/packet_buffer_unittest.cc @@ -188,9 +188,8 @@ TEST(PacketBuffer, InsertPacketList) { ¤t_cng_pt, &mock_stats)); EXPECT_TRUE(list.empty()); // The PacketBuffer should have depleted the list. EXPECT_EQ(10u, buffer.NumPacketsInBuffer()); - EXPECT_EQ(rtc::Optional(0), - current_pt); // Current payload type changed to 0. - EXPECT_FALSE(current_cng_pt); // CNG payload type not changed. + EXPECT_EQ(0, current_pt); // Current payload type changed to 0. + EXPECT_EQ(rtc::nullopt, current_cng_pt); // CNG payload type not changed. buffer.Flush(); // Clean up. @@ -236,9 +235,8 @@ TEST(PacketBuffer, InsertPacketListChangePayloadType) { ¤t_cng_pt, &mock_stats)); EXPECT_TRUE(list.empty()); // The PacketBuffer should have depleted the list. EXPECT_EQ(1u, buffer.NumPacketsInBuffer()); // Only the last packet. - EXPECT_EQ(rtc::Optional(1), - current_pt); // Current payload type changed to 1. - EXPECT_FALSE(current_cng_pt); // CNG payload type not changed. + EXPECT_EQ(1, current_pt); // Current payload type changed to 1. + EXPECT_EQ(rtc::nullopt, current_cng_pt); // CNG payload type not changed. buffer.Flush(); // Clean up. @@ -470,9 +468,8 @@ TEST(PacketBuffer, CngFirstThenSpeechWithNewSampleRate) { EXPECT_EQ(1u, buffer.NumPacketsInBuffer()); ASSERT_TRUE(buffer.PeekNextPacket()); EXPECT_EQ(kCngPt, buffer.PeekNextPacket()->payload_type); - EXPECT_FALSE(current_pt); // Current payload type not set. - EXPECT_EQ(rtc::Optional(kCngPt), - current_cng_pt); // CNG payload type set. + EXPECT_EQ(current_pt, rtc::nullopt); // Current payload type not set. + EXPECT_EQ(kCngPt, current_cng_pt); // CNG payload type set. // Insert second packet, which is wide-band speech. { @@ -490,9 +487,8 @@ TEST(PacketBuffer, CngFirstThenSpeechWithNewSampleRate) { ASSERT_TRUE(buffer.PeekNextPacket()); EXPECT_EQ(kSpeechPt, buffer.PeekNextPacket()->payload_type); - EXPECT_EQ(rtc::Optional(kSpeechPt), - current_pt); // Current payload type set. - EXPECT_FALSE(current_cng_pt); // CNG payload type reset. + EXPECT_EQ(kSpeechPt, current_pt); // Current payload type set. + EXPECT_EQ(rtc::nullopt, current_cng_pt); // CNG payload type reset. buffer.Flush(); // Clean up. EXPECT_CALL(decoder_database, Die()); // Called when object is deleted. diff --git a/modules/audio_coding/neteq/tools/encode_neteq_input.cc b/modules/audio_coding/neteq/tools/encode_neteq_input.cc index d04e8187a1..212b811736 100644 --- a/modules/audio_coding/neteq/tools/encode_neteq_input.cc +++ b/modules/audio_coding/neteq/tools/encode_neteq_input.cc @@ -29,11 +29,11 @@ EncodeNetEqInput::EncodeNetEqInput(std::unique_ptr generator, rtc::Optional EncodeNetEqInput::NextPacketTime() const { RTC_DCHECK(packet_data_); - return rtc::Optional(static_cast(packet_data_->time_ms)); + return static_cast(packet_data_->time_ms); } rtc::Optional EncodeNetEqInput::NextOutputEventTime() const { - return rtc::Optional(next_output_event_ms_); + return next_output_event_ms_; } std::unique_ptr EncodeNetEqInput::PopPacket() { @@ -52,7 +52,7 @@ void EncodeNetEqInput::AdvanceOutputEvent() { rtc::Optional EncodeNetEqInput::NextHeader() const { RTC_DCHECK(packet_data_); - return rtc::Optional(packet_data_->header); + return packet_data_->header; } void EncodeNetEqInput::CreatePacket() { diff --git a/modules/audio_coding/neteq/tools/fake_decode_from_file.cc b/modules/audio_coding/neteq/tools/fake_decode_from_file.cc index 6779e5e9a6..393a46fbcc 100644 --- a/modules/audio_coding/neteq/tools/fake_decode_from_file.cc +++ b/modules/audio_coding/neteq/tools/fake_decode_from_file.cc @@ -59,8 +59,7 @@ int FakeDecodeFromFile::DecodeInternal(const uint8_t* encoded, RTC_CHECK(input_->Seek(jump)); } - next_timestamp_from_input_ = - rtc::Optional(timestamp_to_decode + samples_to_decode); + next_timestamp_from_input_ = timestamp_to_decode + samples_to_decode; uint32_t original_payload_size_bytes = ByteReader::ReadLittleEndian(&encoded[8]); diff --git a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc index 72a539f1d0..34e7a84200 100644 --- a/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc +++ b/modules/audio_coding/neteq/tools/neteq_delay_analyzer.cc @@ -86,12 +86,11 @@ void NetEqDelayAnalyzer::AfterGetAudio(int64_t time_now_ms, auto& it_timing = it->second; RTC_CHECK(!it_timing.decode_get_audio_count) << "Decode time already written"; - it_timing.decode_get_audio_count = rtc::Optional(get_audio_count_); + it_timing.decode_get_audio_count = get_audio_count_; RTC_CHECK(!it_timing.sync_delay_ms) << "Decode time already written"; - it_timing.sync_delay_ms = rtc::Optional(last_sync_buffer_ms_); - it_timing.target_delay_ms = rtc::Optional(neteq->TargetDelayMs()); - it_timing.current_delay_ms = - rtc::Optional(neteq->FilteredCurrentDelayMs()); + it_timing.sync_delay_ms = last_sync_buffer_ms_; + it_timing.target_delay_ms = neteq->TargetDelayMs(); + it_timing.current_delay_ms = neteq->FilteredCurrentDelayMs(); } last_sample_rate_hz_ = audio_frame.sample_rate_hz_; ++get_audio_count_; @@ -159,16 +158,16 @@ void NetEqDelayAnalyzer::CreateGraphs( const float playout_ms = *timing.decode_get_audio_count * 10 + get_audio_time_ms_[0] + *timing.sync_delay_ms - offset_send_time_ms; - playout_delay_ms->push_back(rtc::Optional(playout_ms)); + playout_delay_ms->push_back(playout_ms); RTC_DCHECK(timing.target_delay_ms); RTC_DCHECK(timing.current_delay_ms); const float target = playout_ms - *timing.current_delay_ms + *timing.target_delay_ms; - target_delay_ms->push_back(rtc::Optional(target)); + target_delay_ms->push_back(target); } else { // This packet was never decoded. Mark target and playout delays as empty. - playout_delay_ms->push_back(rtc::Optional()); - target_delay_ms->push_back(rtc::Optional()); + playout_delay_ms->push_back(rtc::nullopt); + target_delay_ms->push_back(rtc::nullopt); } } RTC_DCHECK(data_it == data_.end()); diff --git a/modules/audio_coding/neteq/tools/neteq_input.h b/modules/audio_coding/neteq/tools/neteq_input.h index 993ba04c8f..88d9eb9413 100644 --- a/modules/audio_coding/neteq/tools/neteq_input.h +++ b/modules/audio_coding/neteq/tools/neteq_input.h @@ -52,9 +52,9 @@ class NetEqInput { const auto b = NextOutputEventTime(); // Return the minimum of non-empty |a| and |b|, or empty if both are empty. if (a) { - return b ? rtc::Optional(std::min(*a, *b)) : a; + return b ? std::min(*a, *b) : a; } - return b ? b : rtc::Optional(); + return b ? b : rtc::nullopt; } // Returns the next packet to be inserted into NetEq. The packet following the diff --git a/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc b/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc index 12a12c44db..0741d7c88d 100644 --- a/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc +++ b/modules/audio_coding/neteq/tools/neteq_packet_source_input.cc @@ -25,12 +25,12 @@ NetEqPacketSourceInput::NetEqPacketSourceInput() : next_output_event_ms_(0) {} rtc::Optional NetEqPacketSourceInput::NextPacketTime() const { return packet_ ? rtc::Optional(static_cast(packet_->time_ms())) - : rtc::Optional(); + : rtc::nullopt; } rtc::Optional NetEqPacketSourceInput::NextHeader() const { return packet_ ? rtc::Optional(packet_->header()) - : rtc::Optional(); + : rtc::nullopt; } void NetEqPacketSourceInput::LoadNextPacket() { @@ -78,7 +78,7 @@ void NetEqRtpDumpInput::AdvanceOutputEvent() { *next_output_event_ms_ += kOutputPeriodMs; } if (!NextPacketTime()) { - next_output_event_ms_ = rtc::Optional(); + next_output_event_ms_ = rtc::nullopt; } } @@ -97,14 +97,13 @@ NetEqEventLogInput::NetEqEventLogInput(const std::string& file_name, } rtc::Optional NetEqEventLogInput::NextOutputEventTime() const { - return rtc::Optional(next_output_event_ms_); + return next_output_event_ms_; } void NetEqEventLogInput::AdvanceOutputEvent() { - next_output_event_ms_ = - rtc::Optional(source_->NextAudioOutputEventMs()); + next_output_event_ms_ = source_->NextAudioOutputEventMs(); if (*next_output_event_ms_ == std::numeric_limits::max()) { - next_output_event_ms_ = rtc::Optional(); + next_output_event_ms_ = rtc::nullopt; } } diff --git a/modules/audio_coding/neteq/tools/neteq_replacement_input.cc b/modules/audio_coding/neteq/tools/neteq_replacement_input.cc index a3e3413d82..6c846c0d0d 100644 --- a/modules/audio_coding/neteq/tools/neteq_replacement_input.cc +++ b/modules/audio_coding/neteq/tools/neteq_replacement_input.cc @@ -34,7 +34,7 @@ NetEqReplacementInput::NetEqReplacementInput( rtc::Optional NetEqReplacementInput::NextPacketTime() const { return packet_ ? rtc::Optional(static_cast(packet_->time_ms)) - : rtc::Optional(); + : rtc::nullopt; } rtc::Optional NetEqReplacementInput::NextOutputEventTime() const { diff --git a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc index 7ea73fbadf..4c0f3bf84d 100644 --- a/modules/audio_coding/neteq/tools/neteq_rtpplay.cc +++ b/modules/audio_coding/neteq/tools/neteq_rtpplay.cc @@ -209,20 +209,20 @@ rtc::Optional CodecSampleRate(uint8_t payload_type) { if (payload_type == FLAG_pcmu || payload_type == FLAG_pcma || payload_type == FLAG_ilbc || payload_type == FLAG_pcm16b || payload_type == FLAG_cn_nb || payload_type == FLAG_avt) - return rtc::Optional(8000); + return 8000; if (payload_type == FLAG_isac || payload_type == FLAG_pcm16b_wb || payload_type == FLAG_g722 || payload_type == FLAG_cn_wb || payload_type == FLAG_avt_16) - return rtc::Optional(16000); + return 16000; if (payload_type == FLAG_isac_swb || payload_type == FLAG_pcm16b_swb32 || payload_type == FLAG_cn_swb32 || payload_type == FLAG_avt_32) - return rtc::Optional(32000); + return 32000; if (payload_type == FLAG_opus || payload_type == FLAG_pcm16b_swb48 || payload_type == FLAG_cn_swb48 || payload_type == FLAG_avt_48) - return rtc::Optional(48000); + return 48000; if (payload_type == FLAG_red) - return rtc::Optional(0); - return rtc::Optional(); + return 0; + return rtc::nullopt; } // Class to let through only the packets with a given SSRC. Should be used as an @@ -294,7 +294,7 @@ class SsrcSwitchDetector : public NetEqPostInsertPacket { << static_cast(packet.header.payloadType) << ")" << std::endl; } - last_ssrc_ = rtc::Optional(packet.header.ssrc); + last_ssrc_ = packet.header.ssrc; if (other_callback_) { other_callback_->AfterInsertPacket(packet, neteq); } diff --git a/modules/audio_coding/test/APITest.cc b/modules/audio_coding/test/APITest.cc index 363eb6b304..dbf5ad4534 100644 --- a/modules/audio_coding/test/APITest.cc +++ b/modules/audio_coding/test/APITest.cc @@ -816,7 +816,7 @@ void APITest::TestRegisteration(char sendSide) { if (!myCodec) { CodecInst ci; AudioCodingModule::Codec(_codecCntrA, &ci); - myCodec = rtc::Optional(ci); + myCodec = ci; } if (!_randomTest) { diff --git a/modules/audio_coding/test/PCMFile.cc b/modules/audio_coding/test/PCMFile.cc index 73c8542190..e9e9430a33 100644 --- a/modules/audio_coding/test/PCMFile.cc +++ b/modules/audio_coding/test/PCMFile.cc @@ -225,7 +225,7 @@ void PCMFile::ReadStereo(bool is_stereo) { } void PCMFile::SetNum10MsBlocksToRead(int value) { - num_10ms_blocks_to_read_ = rtc::Optional(value); + num_10ms_blocks_to_read_ = value; } } // namespace webrtc