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

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

Browse Source 
Changes places where we explicitly construct an Optional to instead use
nullopt or the requisite value type only.

This CL was uploaded by git cl split.

R=kwiberg@webrtc.org

Bug: None
Change-Id: I055411a3e521964c81100869a197dd92f5608f1b
Reviewed-on: https://webrtc-review.googlesource.com/23619
Commit-Queue: Oskar Sundbom <ossu@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20728}
This commit is contained in:
Oskar Sundbom
2017-11-16 15:31:38 +01:00
committed by Commit Bot
parent f715c53bca
commit 12ab00b4d8
49 changed files with 435 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc
View File

@ -222,7 +222,7 @@ TEST_F(AudioEncoderCngTest, CheckTargetAudioBitratePropagation) {
CreateCng(MakeCngConfig());
EXPECT_CALL(*mock_encoder_,
OnReceivedUplinkBandwidth(4711, rtc::Optional<int64_t>()));
cng_->OnReceivedUplinkBandwidth(4711, rtc::Optional<int64_t>());
cng_->OnReceivedUplinkBandwidth(4711, rtc::nullopt);
}
TEST_F(AudioEncoderCngTest, CheckPacketLossFractionPropagation) {

4
modules/audio_coding/codecs/legacy_encoded_audio_frame.cc
View File

@ -35,9 +35,9 @@ LegacyEncodedAudioFrame::Decode(rtc::ArrayView<int16_t> decoded) const {
decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
if (ret < 0)
return rtc::Optional<DecodeResult>();
return rtc::nullopt;
return rtc::Optional<DecodeResult>({static_cast<size_t>(ret), speech_type});
return DecodeResult{static_cast<size_t>(ret), speech_type};
}
std::vector<AudioDecoder::ParseResult> LegacyEncodedAudioFrame::SplitBySamples(

4
modules/audio_coding/codecs/opus/audio_decoder_opus.cc
View File

@ -51,9 +51,9 @@ class OpusFrame : public AudioDecoder::EncodedAudioFrame {
}
if (ret < 0)
return rtc::Optional<DecodeResult>();
return rtc::nullopt;
return rtc::Optional<DecodeResult>({static_cast<size_t>(ret), speech_type});
return DecodeResult{static_cast<size_t>(ret), speech_type};
}
private:

38
modules/audio_coding/codecs/opus/audio_encoder_opus.cc
View File

@ -108,9 +108,10 @@ float OptimizePacketLossRate(float new_loss_rate, float old_loss_rate) {
rtc::Optional<std::string> GetFormatParameter(const SdpAudioFormat& format,
const std::string& param) {
auto it = format.parameters.find(param);
return (it == format.parameters.end())
? rtc::Optional<std::string>()
: rtc::Optional<std::string>(it->second);
if (it == format.parameters.end())
return rtc::nullopt;
return it->second;
}
template <typename T>
@ -255,9 +256,9 @@ rtc::Optional<AudioCodecInfo> AudioEncoderOpusImpl::QueryAudioEncoder(
info.allow_comfort_noise = false;
info.supports_network_adaption = true;
return rtc::Optional<AudioCodecInfo>(info);
return info;
}
return rtc::Optional<AudioCodecInfo>();
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<int>(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<AudioEncoderOpusConfig> 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<AudioEncoderOpusConfig>();
return rtc::nullopt;
}
AudioEncoderOpusConfig config;
@ -287,9 +288,9 @@ rtc::Optional<AudioEncoderOpusConfig> 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<int>(
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<AudioEncoderOpusConfig> AudioEncoderOpusImpl::SdpToConfig(
FindSupportedFrameLengths(min_frame_length_ms, max_frame_length_ms,
&config.supported_frame_lengths_ms);
RTC_DCHECK(config.IsOk());
return rtc::Optional<AudioEncoderOpusConfig>(config);
return config;
}
rtc::Optional<int> AudioEncoderOpusImpl::GetNewComplexity(
@ -321,11 +322,11 @@ rtc::Optional<int> AudioEncoderOpusImpl::GetNewComplexity(
bitrate_bps <= config.complexity_threshold_bps +
config.complexity_threshold_window_bps) {
// Within the hysteresis window; make no change.
return rtc::Optional<int>();
return rtc::nullopt;
} else {
return rtc::Optional<int>(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<size_t>(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<int>(rtc::SafeClamp<int>(
config_.bitrate_bps = rtc::SafeClamp<int>(
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<float> smoothed_bitrate = bitrate_smoother_->GetAverage();
if (smoothed_bitrate)
audio_network_adaptor_->SetUplinkBandwidth(*smoothed_bitrate);
bitrate_smoother_last_update_time_ = rtc::Optional<int64_t>(now_ms);
bitrate_smoother_last_update_time_ = now_ms;
}
}
}

70
modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -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<int>(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<int>(kBitrate);
config.frame_length_ms = rtc::Optional<int>(kFrameLength);
config.enable_fec = rtc::Optional<bool>(kEnableFec);
config.enable_dtx = rtc::Optional<bool>(kEnableDtx);
config.num_channels = rtc::Optional<size_t>(kNumChannels);
config.uplink_packet_loss_fraction =
rtc::Optional<float>(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<int64_t>());
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<int64_t>());
states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1, rtc::nullopt);
EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
// Set the minimum rate.
states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps,
rtc::Optional<int64_t>());
states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps, rtc::nullopt);
EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
// Set the maximum rate.
states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps,
rtc::Optional<int64_t>());
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<int64_t>());
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<int64_t>(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<int64_t>());
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<int64_t>());
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<int64_t>());
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<int64_t>());
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<int>(12500);
EXPECT_EQ(rtc::Optional<int>(),
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<int>(10999);
EXPECT_EQ(rtc::Optional<int>(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<int>(12500);
EXPECT_EQ(rtc::Optional<int>(),
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<int>(14001);
EXPECT_EQ(rtc::Optional<int>(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<float>(50000)));
.WillOnce(Return(50000));
EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000));
states.encoder->Encode(
0, rtc::ArrayView<const int16_t>(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<float>(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<int64_t>());
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

8
modules/audio_coding/codecs/opus/opus_complexity_unittest.cc
View File

@ -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<int>(11000 - 1);
config.bitrate_bps = 11000 - 1;
config.low_rate_complexity = 9;
int64_t runtime_10999bps = RunComplexityTest(config);
config.bitrate_bps = rtc::Optional<int>(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<int>(11000 - 1);
config.bitrate_bps = 11000 - 1;
int64_t runtime_10999bps = RunComplexityTest(config);
config.bitrate_bps = rtc::Optional<int>(15500);
config.bitrate_bps = 15500;
int64_t runtime_15500bps = RunComplexityTest(config);
test::PrintResult("opus_encoding_complexity_ratio", "", "adaptation_off",

2
modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc
View File

@ -101,7 +101,7 @@ TEST_F(AudioEncoderCopyRedTest, CheckMaxFrameSizePropagation) {
TEST_F(AudioEncoderCopyRedTest, CheckTargetAudioBitratePropagation) {
EXPECT_CALL(*mock_encoder_,
OnReceivedUplinkBandwidth(4711, rtc::Optional<int64_t>()));
red_->OnReceivedUplinkBandwidth(4711, rtc::Optional<int64_t>());
red_->OnReceivedUplinkBandwidth(4711, rtc::nullopt);
}
TEST_F(AudioEncoderCopyRedTest, CheckPacketLossFractionPropagation) {