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 /api/audio_codecs

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: I30f47ec9b6dbef216ee061a96fad8ca14c041bb5
Reviewed-on: https://webrtc-review.googlesource.com/23566
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20711}
This commit is contained in:
Oskar Sundbom
2017-11-16 10:52:34 +01:00
committed by Commit Bot
parent 18f26d1434
commit 90657302be
18 changed files with 56 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/audio_codecs/L16/audio_decoder_L16.cc
View File

@ -25,7 +25,7 @@ rtc::Optional<AudioDecoderL16::Config> AudioDecoderL16::SdpToConfig(
config.num_channels = rtc::checked_cast<int>(format.num_channels);
return STR_CASE_CMP(format.name.c_str(), "L16") == 0 && config.IsOk()
? rtc::Optional<Config>(config)
: rtc::Optional<Config>();
: rtc::nullopt;
}
void AudioDecoderL16::AppendSupportedDecoders(

4
api/audio_codecs/L16/audio_encoder_L16.cc
View File

@ -21,14 +21,14 @@ namespace webrtc {
rtc::Optional<AudioEncoderL16::Config> AudioEncoderL16::SdpToConfig(
const SdpAudioFormat& format) {
if (!rtc::IsValueInRangeForNumericType<int>(format.num_channels)) {
return rtc::Optional<Config>();
return rtc::nullopt;
}
Config config;
config.sample_rate_hz = format.clockrate_hz;
config.num_channels = rtc::dchecked_cast<int>(format.num_channels);
return STR_CASE_CMP(format.name.c_str(), "L16") == 0 && config.IsOk()
? rtc::Optional<Config>(config)
: rtc::Optional<Config>();
: rtc::nullopt;
}
void AudioEncoderL16::AppendSupportedEncoders(

2
api/audio_codecs/audio_decoder.cc
View File

@ -39,7 +39,7 @@ class OldStyleEncodedFrame final : public AudioDecoder::EncodedAudioFrame {
const int ret = decoder_->Decode(
payload_.data(), payload_.size(), decoder_->SampleRateHz(),
decoded.size() * sizeof(int16_t), decoded.data(), &speech_type);
return ret < 0 ? rtc::Optional<DecodeResult>()
return ret < 0 ? rtc::nullopt
: rtc::Optional<DecodeResult>(
{static_cast<size_t>(ret), speech_type});
}

2
api/audio_codecs/audio_encoder.cc
View File

@ -85,7 +85,7 @@ void AudioEncoder::OnReceivedUplinkRecoverablePacketLossFraction(
float uplink_recoverable_packet_loss_fraction) {}
void AudioEncoder::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) {
OnReceivedUplinkBandwidth(target_audio_bitrate_bps, rtc::Optional<int64_t>());
OnReceivedUplinkBandwidth(target_audio_bitrate_bps, rtc::nullopt);
}
void AudioEncoder::OnReceivedUplinkBandwidth(

2
api/audio_codecs/audio_encoder_factory_template.h
View File

@ -31,7 +31,7 @@ struct Helper<> {
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs) {}
static rtc::Optional<AudioCodecInfo> QueryAudioEncoder(
const SdpAudioFormat& format) {
return rtc::Optional<AudioCodecInfo>();
return rtc::nullopt;
}
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type,

4
api/audio_codecs/g711/audio_decoder_g711.cc
View File

@ -30,9 +30,9 @@ rtc::Optional<AudioDecoderG711::Config> AudioDecoderG711::SdpToConfig(
config.type = is_pcmu ? Config::Type::kPcmU : Config::Type::kPcmA;
config.num_channels = rtc::dchecked_cast<int>(format.num_channels);
RTC_DCHECK(config.IsOk());
return rtc::Optional<Config>(config);
return config;
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

4
api/audio_codecs/g711/audio_encoder_g711.cc
View File

@ -40,9 +40,9 @@ rtc::Optional<AudioEncoderG711::Config> AudioEncoderG711::SdpToConfig(
}
}
RTC_DCHECK(config.IsOk());
return rtc::Optional<Config>(config);
return config;
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

2
api/audio_codecs/g722/audio_decoder_g722.cc
View File

@ -27,7 +27,7 @@ rtc::Optional<AudioDecoderG722::Config> AudioDecoderG722::SdpToConfig(
(format.num_channels == 1 || format.num_channels == 2)
? rtc::Optional<Config>(
Config{rtc::dchecked_cast<int>(format.num_channels)})
: rtc::Optional<Config>();
: rtc::nullopt;
}
void AudioDecoderG722::AppendSupportedDecoders(

4
api/audio_codecs/g722/audio_encoder_g722.cc
View File

@ -26,7 +26,7 @@ rtc::Optional<AudioEncoderG722Config> AudioEncoderG722::SdpToConfig(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), "g722") != 0 ||
format.clockrate_hz != 8000) {
return rtc::Optional<AudioEncoderG722Config>();
return rtc::nullopt;
}
AudioEncoderG722Config config;
@ -40,7 +40,7 @@ rtc::Optional<AudioEncoderG722Config> AudioEncoderG722::SdpToConfig(
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderG722Config>(config)
: rtc::Optional<AudioEncoderG722Config>();
: rtc::nullopt;
}
void AudioEncoderG722::AppendSupportedEncoders(

2
api/audio_codecs/ilbc/audio_decoder_ilbc.cc
View File

@ -24,7 +24,7 @@ rtc::Optional<AudioDecoderIlbc::Config> AudioDecoderIlbc::SdpToConfig(
return STR_CASE_CMP(format.name.c_str(), "ILBC") == 0 &&
format.clockrate_hz == 8000 && format.num_channels == 1
? rtc::Optional<Config>(Config())
: rtc::Optional<Config>();
: rtc::nullopt;
}
void AudioDecoderIlbc::AppendSupportedDecoders(

4
api/audio_codecs/ilbc/audio_encoder_ilbc.cc
View File

@ -42,7 +42,7 @@ rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbc::SdpToConfig(
const SdpAudioFormat& format) {
if (STR_CASE_CMP(format.name.c_str(), "ILBC") != 0 ||
format.clockrate_hz != 8000 || format.num_channels != 1) {
return rtc::Optional<AudioEncoderIlbcConfig>();
return rtc::nullopt;
}
AudioEncoderIlbcConfig config;
@ -55,7 +55,7 @@ rtc::Optional<AudioEncoderIlbcConfig> AudioEncoderIlbc::SdpToConfig(
}
}
return config.IsOk() ? rtc::Optional<AudioEncoderIlbcConfig>(config)
: rtc::Optional<AudioEncoderIlbcConfig>();
: rtc::nullopt;
}
void AudioEncoderIlbc::AppendSupportedEncoders(

2
api/audio_codecs/isac/audio_decoder_isac_fix.cc
View File

@ -21,7 +21,7 @@ rtc::Optional<AudioDecoderIsacFix::Config> AudioDecoderIsacFix::SdpToConfig(
return STR_CASE_CMP(format.name.c_str(), "ISAC") == 0 &&
format.clockrate_hz == 16000 && format.num_channels == 1
? rtc::Optional<Config>(Config())
: rtc::Optional<Config>();
: rtc::nullopt;
}
void AudioDecoderIsacFix::AppendSupportedDecoders(

4
api/audio_codecs/isac/audio_decoder_isac_float.cc
View File

@ -23,9 +23,9 @@ rtc::Optional<AudioDecoderIsacFloat::Config> AudioDecoderIsacFloat::SdpToConfig(
format.num_channels == 1) {
Config config;
config.sample_rate_hz = format.clockrate_hz;
return rtc::Optional<Config>(config);
return config;
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

4
api/audio_codecs/isac/audio_encoder_isac_fix.cc
View File

@ -29,9 +29,9 @@ rtc::Optional<AudioEncoderIsacFix::Config> AudioEncoderIsacFix::SdpToConfig(
config.frame_size_ms = 60;
}
}
return rtc::Optional<Config>(config);
return config;
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

4
api/audio_codecs/isac/audio_encoder_isac_float.cc
View File

@ -35,9 +35,9 @@ rtc::Optional<AudioEncoderIsacFloat::Config> AudioEncoderIsacFloat::SdpToConfig(
}
}
}
return rtc::Optional<Config>(config);
return config;
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

14
api/audio_codecs/opus/audio_decoder_opus.cc
View File

@ -22,25 +22,25 @@ namespace webrtc {
rtc::Optional<AudioDecoderOpus::Config> AudioDecoderOpus::SdpToConfig(
const SdpAudioFormat& format) {
const rtc::Optional<int> num_channels = [&] {
const auto num_channels = [&]() -> rtc::Optional<int> {
auto stereo = format.parameters.find("stereo");
if (stereo != format.parameters.end()) {
if (stereo->second == "0") {
return rtc::Optional<int>(1);
return 1;
} else if (stereo->second == "1") {
return rtc::Optional<int>(2);
return 2;
} else {
return rtc::Optional<int>(); // Bad stereo parameter.
return rtc::nullopt; // Bad stereo parameter.
}
}
return rtc::Optional<int>(1); // Default to mono.
return 1; // Default to mono.
}();
if (STR_CASE_CMP(format.name.c_str(), "opus") == 0 &&
format.clockrate_hz == 48000 && format.num_channels == 2 &&
num_channels) {
return rtc::Optional<Config>(Config{*num_channels});
return Config{*num_channels};
} else {
return rtc::Optional<Config>();
return rtc::nullopt;
}
}

4
api/audio_codecs/test/audio_decoder_factory_template_unittest.cc
View File

@ -47,9 +47,9 @@ struct AudioDecoderFakeApi {
const SdpAudioFormat& audio_format) {
if (Params::AudioFormat() == audio_format) {
MyLittleConfig config = {audio_format};
return rtc::Optional<MyLittleConfig>(config);
return config;
} else {
return rtc::Optional<MyLittleConfig>();
return rtc::nullopt;
}
}

59
api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
View File

@ -47,9 +47,9 @@ struct AudioEncoderFakeApi {
const SdpAudioFormat& audio_format) {
if (Params::AudioFormat() == audio_format) {
MyLittleConfig config = {audio_format};
return rtc::Optional<MyLittleConfig>(config);
return config;
} else {
return rtc::Optional<MyLittleConfig>();
return rtc::nullopt;
}
}
@ -78,8 +78,7 @@ TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
new rtc::RefCountedObject<
audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedEncoders(), testing::IsEmpty());
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
}
@ -88,9 +87,8 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
EXPECT_THAT(factory->GetSupportedEncoders(),
testing::ElementsAre(
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 12345}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
factory->QueryAudioEncoder({"bogus", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
@ -106,12 +104,11 @@ TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}},
AudioCodecSpec{{"sham", 16000, 2, {{"param", "value"}}},
{16000, 2, 23456}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 12345}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
factory->QueryAudioEncoder({"bogus", 8000, 1}));
EXPECT_EQ(
rtc::Optional<AudioCodecInfo>({16000, 2, 23456}),
AudioCodecInfo(16000, 2, 23456),
factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
@ -130,9 +127,8 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
testing::ElementsAre(
AudioCodecSpec{{"PCMU", 8000, 1}, {8000, 1, 64000}},
AudioCodecSpec{{"PCMA", 8000, 1}, {8000, 1, 64000}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"PCMA", 16000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 64000}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 64000),
factory->QueryAudioEncoder({"PCMA", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1});
@ -148,9 +144,8 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
EXPECT_THAT(factory->GetSupportedEncoders(),
testing::ElementsAre(
AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 64000}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 64000),
factory->QueryAudioEncoder({"G722", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1});
@ -163,9 +158,8 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
EXPECT_THAT(factory->GetSupportedEncoders(),
testing::ElementsAre(
AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13333}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({8000, 1, 13333}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 13333),
factory->QueryAudioEncoder({"ilbc", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 8000, 1}));
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1});
@ -178,12 +172,10 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFix) {
EXPECT_THAT(factory->GetSupportedEncoders(),
testing::ElementsAre(AudioCodecSpec{
{"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 32000, 10000, 32000}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
ASSERT_NE(nullptr, enc1);
@ -202,11 +194,10 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFloat) {
testing::ElementsAre(
AudioCodecSpec{{"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}},
AudioCodecSpec{{"ISAC", 32000, 1}, {32000, 1, 56000, 10000, 56000}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({16000, 1, 32000, 10000, 32000}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({32000, 1, 56000, 10000, 56000}),
EXPECT_EQ(AudioCodecInfo(32000, 1, 56000, 10000, 56000),
factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
@ -228,9 +219,8 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
AudioCodecSpec{{"L16", 8000, 2}, {8000, 2, 8000 * 16 * 2}},
AudioCodecSpec{{"L16", 16000, 2}, {16000, 2, 16000 * 16 * 2}},
AudioCodecSpec{{"L16", 32000, 2}, {32000, 2, 32000 * 16 * 2}}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"L16", 8000, 0}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>({48000, 1, 48000 * 16}),
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0}));
EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16),
factory->QueryAudioEncoder({"L16", 48000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"L16", 8000, 0}));
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2});
@ -248,10 +238,9 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
testing::ElementsAre(AudioCodecSpec{
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}},
info}));
EXPECT_EQ(rtc::Optional<AudioCodecInfo>(),
factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(
rtc::Optional<AudioCodecInfo>(info),
info,
factory->QueryAudioEncoder(
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));