admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename Maybe to Optional

Browse Source 
And add examples of good and bad usage to the documentation.

R=aluebs@webrtc.org, henrik.lundin@webrtc.org, pthatcher@webrtc.org

Review URL: https://codereview.webrtc.org/1432553007 .

Cr-Commit-Position: refs/heads/master@{#10588}
This commit is contained in:
Karl Wiberg 2015-11-10 22:34:18 +01:00
parent 5376100d00
commit be57983f4b
33 changed files with 397 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
talk/app/webrtc/localaudiosource.cc
View File

@ -49,7 +49,7 @@ void FromConstraints(const MediaConstraintsInterface::Constraints& constraints,
// a different algorithm will be required.
struct {
const char* name;
rtc::Maybe<bool>& value;
rtc::Optional<bool>& value;
} key_to_value[] = {
{MediaConstraintsInterface::kGoogEchoCancellation,
options->echo_cancellation},
@ -78,7 +78,7 @@ void FromConstraints(const MediaConstraintsInterface::Constraints& constraints,
for (auto& entry : key_to_value) {
if (constraint.key.compare(entry.name) == 0)
entry.value = rtc::Maybe<bool>(value);
entry.value = rtc::Optional<bool>(value);
}
}
}

24
talk/app/webrtc/localaudiosource_unittest.cc
View File

@ -58,14 +58,14 @@ TEST(LocalAudioSourceTest, SetValidOptions) {
LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
&constraints);
EXPECT_EQ(rtc::Maybe<bool>(false), source->options().echo_cancellation);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().extended_filter_aec);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().delay_agnostic_aec);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().auto_gain_control);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().experimental_agc);
EXPECT_EQ(rtc::Maybe<bool>(false), source->options().noise_suppression);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().highpass_filter);
EXPECT_EQ(rtc::Maybe<bool>(true), source->options().aec_dump);
EXPECT_EQ(rtc::Optional<bool>(false), source->options().echo_cancellation);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().extended_filter_aec);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().delay_agnostic_aec);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().auto_gain_control);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().experimental_agc);
EXPECT_EQ(rtc::Optional<bool>(false), source->options().noise_suppression);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().highpass_filter);
EXPECT_EQ(rtc::Optional<bool>(true), source->options().aec_dump);
}
TEST(LocalAudioSourceTest, OptionNotSet) {
@ -73,7 +73,7 @@ TEST(LocalAudioSourceTest, OptionNotSet) {
rtc::scoped_refptr<LocalAudioSource> source =
LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
&constraints);
EXPECT_EQ(rtc::Maybe<bool>(), source->options().highpass_filter);
EXPECT_EQ(rtc::Optional<bool>(), source->options().highpass_filter);
}
TEST(LocalAudioSourceTest, MandatoryOverridesOptional) {
@ -87,7 +87,7 @@ TEST(LocalAudioSourceTest, MandatoryOverridesOptional) {
LocalAudioSource::Create(PeerConnectionFactoryInterface::Options(),
&constraints);
EXPECT_EQ(rtc::Maybe<bool>(false), source->options().echo_cancellation);
EXPECT_EQ(rtc::Optional<bool>(false), source->options().echo_cancellation);
}
TEST(LocalAudioSourceTest, InvalidOptional) {
@ -100,7 +100,7 @@ TEST(LocalAudioSourceTest, InvalidOptional) {
&constraints);
EXPECT_EQ(MediaSourceInterface::kLive, source->state());
EXPECT_EQ(rtc::Maybe<bool>(false), source->options().highpass_filter);
EXPECT_EQ(rtc::Optional<bool>(false), source->options().highpass_filter);
}
TEST(LocalAudioSourceTest, InvalidMandatory) {
@ -113,5 +113,5 @@ TEST(LocalAudioSourceTest, InvalidMandatory) {
&constraints);
EXPECT_EQ(MediaSourceInterface::kLive, source->state());
EXPECT_EQ(rtc::Maybe<bool>(false), source->options().highpass_filter);
EXPECT_EQ(rtc::Optional<bool>(false), source->options().highpass_filter);
}

4
talk/app/webrtc/videosource.cc
View File

@ -268,11 +268,11 @@ const cricket::VideoFormat& GetBestCaptureFormat(
// Return false if the key is mandatory, and the value is invalid.
bool ExtractOption(const MediaConstraintsInterface* all_constraints,
const std::string& key,
rtc::Maybe<bool>* option) {
rtc::Optional<bool>* option) {
size_t mandatory = 0;
bool value;
if (FindConstraint(all_constraints, key, &value, &mandatory)) {
*option = rtc::Maybe<bool>(value);
*option = rtc::Optional<bool>(value);
return true;
}

20
talk/app/webrtc/videosource_unittest.cc
View File

@ -392,13 +392,14 @@ TEST_F(VideoSourceTest, SetValidOptionValues) {
CreateVideoSource(&constraints);
EXPECT_EQ(rtc::Maybe<bool>(false), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(false),
source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, OptionNotSet) {
FakeConstraints constraints;
CreateVideoSource(&constraints);
EXPECT_EQ(rtc::Maybe<bool>(), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(), source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, MandatoryOptionOverridesOptional) {
@ -410,7 +411,8 @@ TEST_F(VideoSourceTest, MandatoryOptionOverridesOptional) {
CreateVideoSource(&constraints);
EXPECT_EQ(rtc::Maybe<bool>(true), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(true),
source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, InvalidOptionKeyOptional) {
@ -423,7 +425,8 @@ TEST_F(VideoSourceTest, InvalidOptionKeyOptional) {
EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
kMaxWaitMs);
EXPECT_EQ(rtc::Maybe<bool>(false), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(false),
source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, InvalidOptionKeyMandatory) {
@ -436,7 +439,7 @@ TEST_F(VideoSourceTest, InvalidOptionKeyMandatory) {
EXPECT_EQ_WAIT(MediaSourceInterface::kEnded, state_observer_->state(),
kMaxWaitMs);
EXPECT_EQ(rtc::Maybe<bool>(), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(), source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, InvalidOptionValueOptional) {
@ -448,7 +451,7 @@ TEST_F(VideoSourceTest, InvalidOptionValueOptional) {
EXPECT_EQ_WAIT(MediaSourceInterface::kLive, state_observer_->state(),
kMaxWaitMs);
EXPECT_EQ(rtc::Maybe<bool>(), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(), source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, InvalidOptionValueMandatory) {
@ -464,7 +467,7 @@ TEST_F(VideoSourceTest, InvalidOptionValueMandatory) {
EXPECT_EQ_WAIT(MediaSourceInterface::kEnded, state_observer_->state(),
kMaxWaitMs);
EXPECT_EQ(rtc::Maybe<bool>(), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(), source_->options()->video_noise_reduction);
}
TEST_F(VideoSourceTest, MixedOptionsAndConstraints) {
@ -487,7 +490,8 @@ TEST_F(VideoSourceTest, MixedOptionsAndConstraints) {
EXPECT_EQ(288, format->height);
EXPECT_EQ(30, format->framerate());
EXPECT_EQ(rtc::Maybe<bool>(false), source_->options()->video_noise_reduction);
EXPECT_EQ(rtc::Optional<bool>(false),
source_->options()->video_noise_reduction);
}
// Tests that the source starts video with the default resolution for

18
talk/app/webrtc/webrtcsession.cc
View File

@ -445,7 +445,7 @@ template <typename T>
static void SetOptionFromOptionalConstraint(
const MediaConstraintsInterface* constraints,
const std::string& key,
rtc::Maybe<T>* option) {
rtc::Optional<T>* option) {
if (!constraints) {
return;
}
@ -453,7 +453,7 @@ static void SetOptionFromOptionalConstraint(
T value;
if (constraints->GetOptional().FindFirst(key, &string_value)) {
if (rtc::FromString(string_value, &value)) {
*option = rtc::Maybe<T>(value);
*option = rtc::Optional<T>(value);
}
}
}
@ -645,8 +645,8 @@ bool WebRtcSession::Initialize(
constraints,
MediaConstraintsInterface::kEnableDscp,
&value, NULL)) {
audio_options_.dscp = rtc::Maybe<bool>(value);
video_options_.dscp = rtc::Maybe<bool>(value);
audio_options_.dscp = rtc::Optional<bool>(value);
video_options_.dscp = rtc::Optional<bool>(value);
}
// Find Suspend Below Min Bitrate constraint.
@ -655,7 +655,7 @@ bool WebRtcSession::Initialize(
MediaConstraintsInterface::kEnableVideoSuspendBelowMinBitrate,
&value,
NULL)) {
video_options_.suspend_below_min_bitrate = rtc::Maybe<bool>(value);
video_options_.suspend_below_min_bitrate = rtc::Optional<bool>(value);
}
SetOptionFromOptionalConstraint(constraints,
@ -686,7 +686,7 @@ bool WebRtcSession::Initialize(
MediaConstraintsInterface::kNumUnsignalledRecvStreams,
&video_options_.unsignalled_recv_stream_limit);
if (video_options_.unsignalled_recv_stream_limit) {
video_options_.unsignalled_recv_stream_limit = rtc::Maybe<int>(
video_options_.unsignalled_recv_stream_limit = rtc::Optional<int>(
std::max(0, std::min(kMaxUnsignalledRecvStreams,
*video_options_.unsignalled_recv_stream_limit)));
}
@ -700,10 +700,10 @@ bool WebRtcSession::Initialize(
&audio_options_.combined_audio_video_bwe);
audio_options_.audio_jitter_buffer_max_packets =
rtc::Maybe<int>(rtc_configuration.audio_jitter_buffer_max_packets);
rtc::Optional<int>(rtc_configuration.audio_jitter_buffer_max_packets);
audio_options_.audio_jitter_buffer_fast_accelerate =
rtc::Maybe<bool>(rtc_configuration.audio_jitter_buffer_fast_accelerate);
audio_options_.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(
rtc_configuration.audio_jitter_buffer_fast_accelerate);
const cricket::VideoCodec default_codec(
JsepSessionDescription::kDefaultVideoCodecId,

14
talk/app/webrtc/webrtcsession_unittest.cc
View File

@ -3297,18 +3297,18 @@ TEST_F(WebRtcSessionTest, SetAudioSend) {
EXPECT_FALSE(channel->IsStreamMuted(send_ssrc));
cricket::AudioOptions options;
options.echo_cancellation = rtc::Maybe<bool>(true);
options.echo_cancellation = rtc::Optional<bool>(true);
rtc::scoped_ptr<FakeAudioRenderer> renderer(new FakeAudioRenderer());
session_->SetAudioSend(send_ssrc, false, options, renderer.get());
EXPECT_TRUE(channel->IsStreamMuted(send_ssrc));
EXPECT_EQ(rtc::Maybe<bool>(), channel->options().echo_cancellation);
EXPECT_EQ(rtc::Optional<bool>(), channel->options().echo_cancellation);
EXPECT_TRUE(renderer->sink() != NULL);
// This will trigger SetSink(NULL) to the |renderer|.
session_->SetAudioSend(send_ssrc, true, options, NULL);
EXPECT_FALSE(channel->IsStreamMuted(send_ssrc));
EXPECT_EQ(rtc::Maybe<bool>(true), channel->options().echo_cancellation);
EXPECT_EQ(rtc::Optional<bool>(true), channel->options().echo_cancellation);
EXPECT_TRUE(renderer->sink() == NULL);
}
@ -3991,8 +3991,8 @@ TEST_F(WebRtcSessionTest, TestDscpConstraint) {
ASSERT_TRUE(voice_channel_ != NULL);
const cricket::AudioOptions& audio_options = voice_channel_->options();
const cricket::VideoOptions& video_options = video_channel_->options();
EXPECT_EQ(rtc::Maybe<bool>(true), audio_options.dscp);
EXPECT_EQ(rtc::Maybe<bool>(true), video_options.dscp);
EXPECT_EQ(rtc::Optional<bool>(true), audio_options.dscp);
EXPECT_EQ(rtc::Optional<bool>(true), video_options.dscp);
}
TEST_F(WebRtcSessionTest, TestSuspendBelowMinBitrateConstraint) {
@ -4010,7 +4010,7 @@ TEST_F(WebRtcSessionTest, TestSuspendBelowMinBitrateConstraint) {
ASSERT_TRUE(video_channel_ != NULL);
const cricket::VideoOptions& video_options = video_channel_->options();
EXPECT_EQ(rtc::Maybe<bool>(true), video_options.suspend_below_min_bitrate);
EXPECT_EQ(rtc::Optional<bool>(true), video_options.suspend_below_min_bitrate);
}
TEST_F(WebRtcSessionTest, TestNumUnsignalledRecvStreamsConstraint) {
@ -4037,7 +4037,7 @@ TEST_F(WebRtcSessionTest, TestCombinedAudioVideoBweConstraint) {
ASSERT_TRUE(voice_channel_ != NULL);
const cricket::AudioOptions& audio_options = voice_channel_->options();
EXPECT_EQ(rtc::Maybe<bool>(true), audio_options.combined_audio_video_bwe);
EXPECT_EQ(rtc::Optional<bool>(true), audio_options.combined_audio_video_bwe);
}
// Tests that we can renegotiate new media content with ICE candidates in the

94
talk/media/base/mediachannel.h
View File

@ -38,7 +38,7 @@
#include "webrtc/base/buffer.h"
#include "webrtc/base/dscp.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
#include "webrtc/base/sigslot.h"
#include "webrtc/base/socket.h"
#include "webrtc/base/window.h"
@ -65,7 +65,7 @@ const int kMaxRtpHeaderExtensionId = 255;
const int kScreencastDefaultFps = 5;
template <class T>
static std::string ToStringIfSet(const char* key, const rtc::Maybe<T>& val) {
static std::string ToStringIfSet(const char* key, const rtc::Optional<T>& val) {
std::string str;
if (val) {
str = key;
@ -186,43 +186,43 @@ struct AudioOptions {
// Audio processing that attempts to filter away the output signal from
// later inbound pickup.
rtc::Maybe<bool> echo_cancellation;
rtc::Optional<bool> echo_cancellation;
// Audio processing to adjust the sensitivity of the local mic dynamically.
rtc::Maybe<bool> auto_gain_control;
rtc::Optional<bool> auto_gain_control;
// Audio processing to filter out background noise.
rtc::Maybe<bool> noise_suppression;
rtc::Optional<bool> noise_suppression;
// Audio processing to remove background noise of lower frequencies.
rtc::Maybe<bool> highpass_filter;
rtc::Optional<bool> highpass_filter;
// Audio processing to swap the left and right channels.
rtc::Maybe<bool> stereo_swapping;
rtc::Optional<bool> stereo_swapping;
// Audio receiver jitter buffer (NetEq) max capacity in number of packets.
rtc::Maybe<int> audio_jitter_buffer_max_packets;
rtc::Optional<int> audio_jitter_buffer_max_packets;
// Audio receiver jitter buffer (NetEq) fast accelerate mode.
rtc::Maybe<bool> audio_jitter_buffer_fast_accelerate;
rtc::Optional<bool> audio_jitter_buffer_fast_accelerate;
// Audio processing to detect typing.
rtc::Maybe<bool> typing_detection;
rtc::Maybe<bool> aecm_generate_comfort_noise;
rtc::Maybe<bool> conference_mode;
rtc::Maybe<int> adjust_agc_delta;
rtc::Maybe<bool> experimental_agc;
rtc::Maybe<bool> extended_filter_aec;
rtc::Maybe<bool> delay_agnostic_aec;
rtc::Maybe<bool> experimental_ns;
rtc::Maybe<bool> aec_dump;
rtc::Optional<bool> typing_detection;
rtc::Optional<bool> aecm_generate_comfort_noise;
rtc::Optional<bool> conference_mode;
rtc::Optional<int> adjust_agc_delta;
rtc::Optional<bool> experimental_agc;
rtc::Optional<bool> extended_filter_aec;
rtc::Optional<bool> delay_agnostic_aec;
rtc::Optional<bool> experimental_ns;
rtc::Optional<bool> aec_dump;
// Note that tx_agc_* only applies to non-experimental AGC.
rtc::Maybe<uint16_t> tx_agc_target_dbov;
rtc::Maybe<uint16_t> tx_agc_digital_compression_gain;
rtc::Maybe<bool> tx_agc_limiter;
rtc::Maybe<uint32_t> recording_sample_rate;
rtc::Maybe<uint32_t> playout_sample_rate;
rtc::Optional<uint16_t> tx_agc_target_dbov;
rtc::Optional<uint16_t> tx_agc_digital_compression_gain;
rtc::Optional<bool> tx_agc_limiter;
rtc::Optional<uint32_t> recording_sample_rate;
rtc::Optional<uint32_t> playout_sample_rate;
// Set DSCP value for packet sent from audio channel.
rtc::Maybe<bool> dscp;
rtc::Optional<bool> dscp;
// Enable combined audio+bandwidth BWE.
rtc::Maybe<bool> combined_audio_video_bwe;
rtc::Optional<bool> combined_audio_video_bwe;
private:
template <typename T>
static void SetFrom(rtc::Maybe<T>* s, const rtc::Maybe<T>& o) {
static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) {
if (o) {
*s = o;
}
@ -329,60 +329,60 @@ struct VideoOptions {
}
// Enable CPU adaptation?
rtc::Maybe<bool> adapt_input_to_cpu_usage;
rtc::Optional<bool> adapt_input_to_cpu_usage;
// Enable CPU adaptation smoothing?
rtc::Maybe<bool> adapt_cpu_with_smoothing;
rtc::Optional<bool> adapt_cpu_with_smoothing;
// Enable video adapt third?
rtc::Maybe<bool> video_adapt_third;
rtc::Optional<bool> video_adapt_third;
// Enable denoising?
rtc::Maybe<bool> video_noise_reduction;
rtc::Optional<bool> video_noise_reduction;
// Experimental: Enable WebRtc higher start bitrate?
rtc::Maybe<int> video_start_bitrate;
rtc::Optional<int> video_start_bitrate;
// Enable WebRTC Cpu Overuse Detection, which is a new version of the CPU
// adaptation algorithm. So this option will override the
// |adapt_input_to_cpu_usage|.
rtc::Maybe<bool> cpu_overuse_detection;
rtc::Optional<bool> cpu_overuse_detection;
// Low threshold (t1) for cpu overuse adaptation. (Adapt up)
// Metric: encode usage (m1). m1 < t1 => underuse.
rtc::Maybe<int> cpu_underuse_threshold;
rtc::Optional<int> cpu_underuse_threshold;
// High threshold (t1) for cpu overuse adaptation. (Adapt down)
// Metric: encode usage (m1). m1 > t1 => overuse.
rtc::Maybe<int> cpu_overuse_threshold;
rtc::Optional<int> cpu_overuse_threshold;
// Low threshold (t2) for cpu overuse adaptation. (Adapt up)
// Metric: relative standard deviation of encode time (m2).
// Optional threshold. If set, (m1 < t1 && m2 < t2) => underuse.
// Note: t2 will have no effect if t1 is not set.
rtc::Maybe<int> cpu_underuse_encode_rsd_threshold;
rtc::Optional<int> cpu_underuse_encode_rsd_threshold;
// High threshold (t2) for cpu overuse adaptation. (Adapt down)
// Metric: relative standard deviation of encode time (m2).
// Optional threshold. If set, (m1 > t1 || m2 > t2) => overuse.
// Note: t2 will have no effect if t1 is not set.
rtc::Maybe<int> cpu_overuse_encode_rsd_threshold;
rtc::Optional<int> cpu_overuse_encode_rsd_threshold;
// Use encode usage for cpu detection.
rtc::Maybe<bool> cpu_overuse_encode_usage;
rtc::Optional<bool> cpu_overuse_encode_usage;
// Use conference mode?
rtc::Maybe<bool> conference_mode;
rtc::Optional<bool> conference_mode;
// Threshhold for process cpu adaptation. (Process limit)
rtc::Maybe<float> process_adaptation_threshhold;
rtc::Optional<float> process_adaptation_threshhold;
// Low threshhold for cpu adaptation. (Adapt up)
rtc::Maybe<float> system_low_adaptation_threshhold;
rtc::Optional<float> system_low_adaptation_threshhold;
// High threshhold for cpu adaptation. (Adapt down)
rtc::Maybe<float> system_high_adaptation_threshhold;
rtc::Optional<float> system_high_adaptation_threshhold;
// Set DSCP value for packet sent from video channel.
rtc::Maybe<bool> dscp;
rtc::Optional<bool> dscp;
// Enable WebRTC suspension of video. No video frames will be sent when the
// bitrate is below the configured minimum bitrate.
rtc::Maybe<bool> suspend_below_min_bitrate;
rtc::Optional<bool> suspend_below_min_bitrate;
// Limit on the number of early receive channels that can be created.
rtc::Maybe<int> unsignalled_recv_stream_limit;
rtc::Optional<int> unsignalled_recv_stream_limit;
// Enable use of simulcast adapter.
rtc::Maybe<bool> use_simulcast_adapter;
rtc::Optional<bool> use_simulcast_adapter;
// Force screencast to use a minimum bitrate
rtc::Maybe<int> screencast_min_bitrate;
rtc::Optional<int> screencast_min_bitrate;
private:
template <typename T>
static void SetFrom(rtc::Maybe<T>* s, const rtc::Maybe<T>& o) {
static void SetFrom(rtc::Optional<T>* s, const rtc::Optional<T>& o) {
if (o) {
*s = o;
}

14
talk/media/base/videoengine_unittest.h
View File

@ -875,7 +875,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(DefaultCodec());
parameters.options.conference_mode = rtc::Maybe<bool>(true);
parameters.options.conference_mode = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->AddRecvStream(
@ -926,7 +926,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(SetOneCodec(DefaultCodec()));
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(DefaultCodec());
parameters.options.conference_mode = rtc::Maybe<bool>(true);
parameters.options.conference_mode = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->AddRecvStream(
cricket::StreamParams::CreateLegacy(kSsrc)));
@ -1236,7 +1236,7 @@ class VideoMediaChannelTest : public testing::Test,
EXPECT_TRUE(SetDefaultCodec());
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(DefaultCodec());
parameters.options.conference_mode = rtc::Maybe<bool>(true);
parameters.options.conference_mode = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(SetSend(true));
EXPECT_TRUE(channel_->AddRecvStream(
@ -1746,8 +1746,8 @@ class VideoMediaChannelTest : public testing::Test,
// Tests that we can send and receive frames with early receive.
void TwoStreamsSendAndUnsignalledRecv(const cricket::VideoCodec& codec) {
cricket::VideoSendParameters parameters;
parameters.options.conference_mode = rtc::Maybe<bool>(true);
parameters.options.unsignalled_recv_stream_limit = rtc::Maybe<int>(1);
parameters.options.conference_mode = rtc::Optional<bool>(true);
parameters.options.unsignalled_recv_stream_limit = rtc::Optional<int>(1);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
SetUpSecondStreamWithNoRecv();
// Test sending and receiving on first stream.
@ -1780,8 +1780,8 @@ class VideoMediaChannelTest : public testing::Test,
void TwoStreamsAddAndRemoveUnsignalledRecv(
const cricket::VideoCodec& codec) {
cricket::VideoOptions vmo;
vmo.conference_mode = rtc::Maybe<bool>(true);
vmo.unsignalled_recv_stream_limit = rtc::Maybe<int>(1);
vmo.conference_mode = rtc::Optional<bool>(true);
vmo.unsignalled_recv_stream_limit = rtc::Optional<int>(1);
EXPECT_TRUE(channel_->SetOptions(vmo));
SetUpSecondStreamWithNoRecv();
// Sending and receiving on first stream.

16
talk/media/webrtc/webrtcvideoengine2.cc
View File

@ -786,10 +786,10 @@ WebRtcVideoChannel2::WebRtcVideoChannel2(
}
void WebRtcVideoChannel2::SetDefaultOptions() {
options_.cpu_overuse_detection = rtc::Maybe<bool>(true);
options_.dscp = rtc::Maybe<bool>(false);
options_.suspend_below_min_bitrate = rtc::Maybe<bool>(false);
options_.screencast_min_bitrate = rtc::Maybe<int>(0);
options_.cpu_overuse_detection = rtc::Optional<bool>(true);
options_.dscp = rtc::Optional<bool>(false);
options_.suspend_below_min_bitrate = rtc::Optional<bool>(false);
options_.screencast_min_bitrate = rtc::Optional<int>(0);
}
WebRtcVideoChannel2::~WebRtcVideoChannel2() {
@ -960,7 +960,7 @@ bool WebRtcVideoChannel2::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
return true;
}
send_codec_ = rtc::Maybe<WebRtcVideoChannel2::VideoCodecSettings>(
send_codec_ = rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(
supported_codecs.front());
rtc::CritScope stream_lock(&stream_crit_);
@ -1704,7 +1704,7 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters::
const webrtc::VideoSendStream::Config& config,
const VideoOptions& options,
int max_bitrate_bps,
const rtc::Maybe<VideoCodecSettings>& codec_settings)
const rtc::Optional<VideoCodecSettings>& codec_settings)
: config(config),
options(options),
max_bitrate_bps(max_bitrate_bps),
@ -1732,7 +1732,7 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream(
WebRtcVideoEncoderFactory* external_encoder_factory,
const VideoOptions& options,
int max_bitrate_bps,
const rtc::Maybe<VideoCodecSettings>& codec_settings,
const rtc::Optional<VideoCodecSettings>& codec_settings,
const std::vector<webrtc::RtpExtension>& rtp_extensions)
: ssrcs_(sp.ssrcs),
ssrc_groups_(sp.ssrc_groups),
@ -2047,7 +2047,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
*options.suspend_below_min_bitrate;
parameters_.codec_settings =
rtc::Maybe<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings);
parameters_.options = options;
LOG(LS_INFO)

8
talk/media/webrtc/webrtcvideoengine2.h
View File

@ -250,7 +250,7 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
WebRtcVideoEncoderFactory* external_encoder_factory,
const VideoOptions& options,
int max_bitrate_bps,
const rtc::Maybe<VideoCodecSettings>& codec_settings,
const rtc::Optional<VideoCodecSettings>& codec_settings,
const std::vector<webrtc::RtpExtension>& rtp_extensions);
~WebRtcVideoSendStream();
@ -286,11 +286,11 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
const webrtc::VideoSendStream::Config& config,
const VideoOptions& options,
int max_bitrate_bps,
const rtc::Maybe<VideoCodecSettings>& codec_settings);
const rtc::Optional<VideoCodecSettings>& codec_settings);
webrtc::VideoSendStream::Config config;
VideoOptions options;
int max_bitrate_bps;
rtc::Maybe<VideoCodecSettings> codec_settings;
rtc::Optional<VideoCodecSettings> codec_settings;
// Sent resolutions + bitrates etc. by the underlying VideoSendStream,
// typically changes when setting a new resolution or reconfiguring
// bitrates.
@ -512,7 +512,7 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
std::set<uint32_t> send_ssrcs_ GUARDED_BY(stream_crit_);
std::set<uint32_t> receive_ssrcs_ GUARDED_BY(stream_crit_);
rtc::Maybe<VideoCodecSettings> send_codec_;
rtc::Optional<VideoCodecSettings> send_codec_;
std::vector<webrtc::RtpExtension> send_rtp_extensions_;
WebRtcVideoEncoderFactory* const external_encoder_factory_;

22
talk/media/webrtc/webrtcvideoengine2_unittest.cc
View File

@ -1097,7 +1097,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
FakeVideoSendStream* SetDenoisingOption(
const cricket::VideoSendParameters& parameters, bool enabled) {
cricket::VideoSendParameters params = parameters;
params.options.video_noise_reduction = rtc::Maybe<bool>(enabled);
params.options.video_noise_reduction = rtc::Optional<bool>(enabled);
channel_->SetSendParameters(params);
return fake_call_->GetVideoSendStreams().back();
}
@ -1148,7 +1148,7 @@ TEST_F(WebRtcVideoChannel2Test, RecvStreamWithSimAndRtx) {
parameters.codecs = engine_.codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true));
parameters.options.conference_mode = rtc::Maybe<bool>(true);
parameters.options.conference_mode = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
// Send side.
@ -1559,7 +1559,7 @@ TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
parameters.options.screencast_min_bitrate =
rtc::Maybe<int>(kScreenshareMinBitrateKbps);
rtc::Optional<int>(kScreenshareMinBitrateKbps);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
AddSendStream();
@ -1613,7 +1613,7 @@ TEST_F(WebRtcVideoChannel2Test,
ConferenceModeScreencastConfiguresTemporalLayer) {
static const int kConferenceScreencastTemporalBitrateBps =
ScreenshareLayerConfig::GetDefault().tl0_bitrate_kbps * 1000;
send_parameters_.options.conference_mode = rtc::Maybe<bool>(true);
send_parameters_.options.conference_mode = rtc::Optional<bool>(true);
channel_->SetSendParameters(send_parameters_);
AddSendStream();
@ -1660,13 +1660,15 @@ TEST_F(WebRtcVideoChannel2Test, SuspendBelowMinBitrateDisabledByDefault) {
}
TEST_F(WebRtcVideoChannel2Test, SetOptionsWithSuspendBelowMinBitrate) {
send_parameters_.options.suspend_below_min_bitrate = rtc::Maybe<bool>(true);
send_parameters_.options.suspend_below_min_bitrate =
rtc::Optional<bool>(true);
channel_->SetSendParameters(send_parameters_);
FakeVideoSendStream* stream = AddSendStream();
EXPECT_TRUE(stream->GetConfig().suspend_below_min_bitrate);
send_parameters_.options.suspend_below_min_bitrate = rtc::Maybe<bool>(false);
send_parameters_.options.suspend_below_min_bitrate =
rtc::Optional<bool>(false);
channel_->SetSendParameters(send_parameters_);
stream = fake_call_->GetVideoSendStreams()[0];
@ -1854,7 +1856,7 @@ void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
if (!enable_overuse) {
parameters.options.cpu_overuse_detection = rtc::Maybe<bool>(false);
parameters.options.cpu_overuse_detection = rtc::Optional<bool>(false);
}
EXPECT_TRUE(channel_->SetSendParameters(parameters));
@ -2376,14 +2378,14 @@ TEST_F(WebRtcVideoChannel2Test, TestSetDscpOptions) {
cricket::VideoSendParameters parameters = send_parameters_;
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_EQ(rtc::DSCP_NO_CHANGE, network_interface->dscp());
parameters.options.dscp = rtc::Maybe<bool>(true);
parameters.options.dscp = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
// Verify previous value is not modified if dscp option is not set.
cricket::VideoSendParameters parameters1 = send_parameters_;
EXPECT_TRUE(channel_->SetSendParameters(parameters1));
EXPECT_EQ(rtc::DSCP_AF41, network_interface->dscp());
parameters1.options.dscp = rtc::Maybe<bool>(false);
parameters1.options.dscp = rtc::Optional<bool>(false);
EXPECT_TRUE(channel_->SetSendParameters(parameters1));
EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
channel_->SetInterface(NULL);
@ -2461,7 +2463,7 @@ TEST_F(WebRtcVideoChannel2Test, GetStatsTracksAdaptationStats) {
EXPECT_TRUE(channel_->SetSend(true));
// Verify that the CpuOveruseObserver is registered and trigger downgrade.
parameters.options.cpu_overuse_detection = rtc::Maybe<bool>(true);
parameters.options.cpu_overuse_detection = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
// Trigger overuse.

50
talk/media/webrtc/webrtcvoiceengine.cc
View File

@ -368,20 +368,20 @@ void MaybeFixupG722(webrtc::CodecInst* voe_codec, int new_plfreq) {
// ns, and highpass) and the rest hardcoded in InitInternal.
AudioOptions GetDefaultEngineOptions() {
AudioOptions options;
options.echo_cancellation = rtc::Maybe<bool>(true);
options.auto_gain_control = rtc::Maybe<bool>(true);
options.noise_suppression = rtc::Maybe<bool>(true);
options.highpass_filter = rtc::Maybe<bool>(true);
options.stereo_swapping = rtc::Maybe<bool>(false);
options.audio_jitter_buffer_max_packets = rtc::Maybe<int>(50);
options.audio_jitter_buffer_fast_accelerate = rtc::Maybe<bool>(false);
options.typing_detection = rtc::Maybe<bool>(true);
options.adjust_agc_delta = rtc::Maybe<int>(0);
options.experimental_agc = rtc::Maybe<bool>(false);
options.extended_filter_aec = rtc::Maybe<bool>(false);
options.delay_agnostic_aec = rtc::Maybe<bool>(false);
options.experimental_ns = rtc::Maybe<bool>(false);
options.aec_dump = rtc::Maybe<bool>(false);
options.echo_cancellation = rtc::Optional<bool>(true);
options.auto_gain_control = rtc::Optional<bool>(true);
options.noise_suppression = rtc::Optional<bool>(true);
options.highpass_filter = rtc::Optional<bool>(true);
options.stereo_swapping = rtc::Optional<bool>(false);
options.audio_jitter_buffer_max_packets = rtc::Optional<int>(50);
options.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(false);
options.typing_detection = rtc::Optional<bool>(true);
options.adjust_agc_delta = rtc::Optional<int>(0);
options.experimental_agc = rtc::Optional<bool>(false);
options.extended_filter_aec = rtc::Optional<bool>(false);
options.delay_agnostic_aec = rtc::Optional<bool>(false);
options.experimental_ns = rtc::Optional<bool>(false);
options.aec_dump = rtc::Optional<bool>(false);
return options;
}
@ -640,8 +640,8 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
#if defined(IOS)
// On iOS, VPIO provides built-in EC and AGC.
options.echo_cancellation = rtc::Maybe<bool>(false);
options.auto_gain_control = rtc::Maybe<bool>(false);
options.echo_cancellation = rtc::Optional<bool>(false);
options.auto_gain_control = rtc::Optional<bool>(false);
LOG(LS_INFO) << "Always disable AEC and AGC on iOS. Use built-in instead.";
#elif defined(ANDROID)
ec_mode = webrtc::kEcAecm;
@ -651,10 +651,10 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
// Set the AGC mode for iOS as well despite disabling it above, to avoid
// unsupported configuration errors from webrtc.
agc_mode = webrtc::kAgcFixedDigital;
options.typing_detection = rtc::Maybe<bool>(false);
options.experimental_agc = rtc::Maybe<bool>(false);
options.extended_filter_aec = rtc::Maybe<bool>(false);
options.experimental_ns = rtc::Maybe<bool>(false);
options.typing_detection = rtc::Optional<bool>(false);
options.experimental_agc = rtc::Optional<bool>(false);
options.extended_filter_aec = rtc::Optional<bool>(false);
options.experimental_ns = rtc::Optional<bool>(false);
#endif
// Delay Agnostic AEC automatically turns on EC if not set except on iOS
@ -664,8 +664,8 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
if (options.delay_agnostic_aec) {
use_delay_agnostic_aec = *options.delay_agnostic_aec;
if (use_delay_agnostic_aec) {
options.echo_cancellation = rtc::Maybe<bool>(true);
options.extended_filter_aec = rtc::Maybe<bool>(true);
options.echo_cancellation = rtc::Optional<bool>(true);
options.extended_filter_aec = rtc::Optional<bool>(true);
ec_mode = webrtc::kEcConference;
}
}
@ -689,7 +689,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
enable_built_in_aec) {
// Disable internal software EC if built-in EC is enabled,
// i.e., replace the software EC with the built-in EC.
options.echo_cancellation = rtc::Maybe<bool>(false);
options.echo_cancellation = rtc::Optional<bool>(false);
LOG(LS_INFO) << "Disabling EC since built-in EC will be used instead";
}
}
@ -724,7 +724,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
*options.auto_gain_control) {
// Disable internal software AGC if built-in AGC is enabled,
// i.e., replace the software AGC with the built-in AGC.
options.auto_gain_control = rtc::Maybe<bool>(false);
options.auto_gain_control = rtc::Optional<bool>(false);
LOG(LS_INFO) << "Disabling AGC since built-in AGC will be used instead";
}
}
@ -771,7 +771,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
*options.noise_suppression) {
// Disable internal software NS if built-in NS is enabled,
// i.e., replace the software NS with the built-in NS.
options.noise_suppression = rtc::Maybe<bool>(false);
options.noise_suppression = rtc::Optional<bool>(false);
LOG(LS_INFO) << "Disabling NS since built-in NS will be used instead";
}
}

6
talk/media/webrtc/webrtcvoiceengine.h
View File

@ -168,9 +168,9 @@ class WebRtcVoiceEngine final : public webrtc::TraceCallback {
// values, and apply them in case they are missing in the audio options. We
// need to do this because SetExtraOptions() will revert to defaults for
// options which are not provided.
rtc::Maybe<bool> extended_filter_aec_;
rtc::Maybe<bool> delay_agnostic_aec_;
rtc::Maybe<bool> experimental_ns_;
rtc::Optional<bool> extended_filter_aec_;
rtc::Optional<bool> delay_agnostic_aec_;
rtc::Optional<bool> experimental_ns_;
RTC_DISALLOW_COPY_AND_ASSIGN(WebRtcVoiceEngine);
};

93
talk/media/webrtc/webrtcvoiceengine_unittest.cc
View File

@ -97,7 +97,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
channel_(nullptr) {
send_parameters_.codecs.push_back(kPcmuCodec);
recv_parameters_.codecs.push_back(kPcmuCodec);
options_adjust_agc_.adjust_agc_delta = rtc::Maybe<int>(-10);
options_adjust_agc_.adjust_agc_delta = rtc::Optional<int>(-10);
}
bool SetupEngine() {
if (!engine_.Init(rtc::Thread::Current())) {
@ -2282,10 +2282,10 @@ TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
EXPECT_EQ(0, agc_config.targetLeveldBOv);
cricket::AudioOptions options;
options.tx_agc_target_dbov = rtc::Maybe<uint16_t>(3);
options.tx_agc_digital_compression_gain = rtc::Maybe<uint16_t>(9);
options.tx_agc_limiter = rtc::Maybe<bool>(true);
options.auto_gain_control = rtc::Maybe<bool>(true);
options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3);
options.tx_agc_digital_compression_gain = rtc::Optional<uint16_t>(9);
options.tx_agc_limiter = rtc::Optional<bool>(true);
options.auto_gain_control = rtc::Optional<bool>(true);
EXPECT_TRUE(engine_.SetOptions(options));
EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
@ -2295,7 +2295,7 @@ TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
// Check interaction with adjust_agc_delta. Both should be respected, for
// backwards compatibility.
options.adjust_agc_delta = rtc::Maybe<int>(-10);
options.adjust_agc_delta = rtc::Optional<int>(-10);
EXPECT_TRUE(engine_.SetOptions(options));
EXPECT_EQ(0, voe_.GetAgcConfig(agc_config));
@ -2305,8 +2305,8 @@ TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
TEST_F(WebRtcVoiceEngineTestFake, SampleRatesViaOptions) {
EXPECT_TRUE(SetupEngineWithSendStream());
cricket::AudioOptions options;
options.recording_sample_rate = rtc::Maybe<uint32_t>(48000);
options.playout_sample_rate = rtc::Maybe<uint32_t>(44100);
options.recording_sample_rate = rtc::Optional<uint32_t>(48000);
options.playout_sample_rate = rtc::Optional<uint32_t>(44100);
EXPECT_TRUE(engine_.SetOptions(options));
unsigned int recording_sample_rate, playout_sample_rate;
@ -2639,14 +2639,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
voe_.GetNetEqFastAccelerate()); // From GetDefaultEngineOptions().
// Turn echo cancellation off
options.echo_cancellation = rtc::Maybe<bool>(false);
options.echo_cancellation = rtc::Optional<bool>(false);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetEcStatus(ec_enabled, ec_mode);
EXPECT_FALSE(ec_enabled);
// Turn echo cancellation back on, with settings, and make sure
// nothing else changed.
options.echo_cancellation = rtc::Maybe<bool>(true);
options.echo_cancellation = rtc::Optional<bool>(true);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetEcStatus(ec_enabled, ec_mode);
voe_.GetAecmMode(aecm_mode, cng_enabled);
@ -2669,7 +2669,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
// Turn on delay agnostic aec and make sure nothing change w.r.t. echo
// control.
options.delay_agnostic_aec = rtc::Maybe<bool>(true);
options.delay_agnostic_aec = rtc::Optional<bool>(true);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetEcStatus(ec_enabled, ec_mode);
voe_.GetAecmMode(aecm_mode, cng_enabled);
@ -2678,14 +2678,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_EQ(ec_mode, webrtc::kEcConference);
// Turn off echo cancellation and delay agnostic aec.
options.delay_agnostic_aec = rtc::Maybe<bool>(false);
options.extended_filter_aec = rtc::Maybe<bool>(false);
options.echo_cancellation = rtc::Maybe<bool>(false);
options.delay_agnostic_aec = rtc::Optional<bool>(false);
options.extended_filter_aec = rtc::Optional<bool>(false);
options.echo_cancellation = rtc::Optional<bool>(false);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetEcStatus(ec_enabled, ec_mode);
EXPECT_FALSE(ec_enabled);
// Turning delay agnostic aec back on should also turn on echo cancellation.
options.delay_agnostic_aec = rtc::Maybe<bool>(true);
options.delay_agnostic_aec = rtc::Optional<bool>(true);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetEcStatus(ec_enabled, ec_mode);
EXPECT_TRUE(ec_enabled);
@ -2693,14 +2693,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_EQ(ec_mode, webrtc::kEcConference);
// Turn off AGC
options.auto_gain_control = rtc::Maybe<bool>(false);
options.auto_gain_control = rtc::Optional<bool>(false);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetAgcStatus(agc_enabled, agc_mode);
EXPECT_FALSE(agc_enabled);
// Turn AGC back on
options.auto_gain_control = rtc::Maybe<bool>(true);
options.adjust_agc_delta = rtc::Maybe<int>();
options.auto_gain_control = rtc::Optional<bool>(true);
options.adjust_agc_delta = rtc::Optional<int>();
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetAgcStatus(agc_enabled, agc_mode);
EXPECT_TRUE(agc_enabled);
@ -2708,10 +2708,10 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_EQ(0, agc_config.targetLeveldBOv);
// Turn off other options (and stereo swapping on).
options.noise_suppression = rtc::Maybe<bool>(false);
options.highpass_filter = rtc::Maybe<bool>(false);
options.typing_detection = rtc::Maybe<bool>(false);
options.stereo_swapping = rtc::Maybe<bool>(true);
options.noise_suppression = rtc::Optional<bool>(false);
options.highpass_filter = rtc::Optional<bool>(false);
options.typing_detection = rtc::Optional<bool>(false);
options.stereo_swapping = rtc::Optional<bool>(true);
ASSERT_TRUE(engine_.SetOptions(options));
voe_.GetNsStatus(ns_enabled, ns_mode);
highpass_filter_enabled = voe_.IsHighPassFilterEnabled();
@ -2794,9 +2794,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
// AEC and AGC and NS
cricket::AudioSendParameters parameters_options_all = send_parameters_;
parameters_options_all.options.echo_cancellation = rtc::Maybe<bool>(true);
parameters_options_all.options.auto_gain_control = rtc::Maybe<bool>(true);
parameters_options_all.options.noise_suppression = rtc::Maybe<bool>(true);
parameters_options_all.options.echo_cancellation = rtc::Optional<bool>(true);
parameters_options_all.options.auto_gain_control = rtc::Optional<bool>(true);
parameters_options_all.options.noise_suppression = rtc::Optional<bool>(true);
ASSERT_TRUE(channel1->SetSendParameters(parameters_options_all));
EXPECT_EQ(parameters_options_all.options, channel1->options());
ASSERT_TRUE(channel2->SetSendParameters(parameters_options_all));
@ -2804,21 +2804,23 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
// unset NS
cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
parameters_options_no_ns.options.noise_suppression = rtc::Maybe<bool>(false);
parameters_options_no_ns.options.noise_suppression =
rtc::Optional<bool>(false);
ASSERT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
cricket::AudioOptions expected_options = parameters_options_all.options;
expected_options.echo_cancellation = rtc::Maybe<bool>(true);
expected_options.auto_gain_control = rtc::Maybe<bool>(true);
expected_options.noise_suppression = rtc::Maybe<bool>(false);
expected_options.echo_cancellation = rtc::Optional<bool>(true);
expected_options.auto_gain_control = rtc::Optional<bool>(true);
expected_options.noise_suppression = rtc::Optional<bool>(false);
EXPECT_EQ(expected_options, channel1->options());
// unset AGC
cricket::AudioSendParameters parameters_options_no_agc = send_parameters_;
parameters_options_no_agc.options.auto_gain_control = rtc::Maybe<bool>(false);
parameters_options_no_agc.options.auto_gain_control =
rtc::Optional<bool>(false);
ASSERT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
expected_options.echo_cancellation = rtc::Maybe<bool>(true);
expected_options.auto_gain_control = rtc::Maybe<bool>(false);
expected_options.noise_suppression = rtc::Maybe<bool>(true);
expected_options.echo_cancellation = rtc::Optional<bool>(true);
expected_options.auto_gain_control = rtc::Optional<bool>(false);
expected_options.noise_suppression = rtc::Optional<bool>(true);
EXPECT_EQ(expected_options, channel2->options());
ASSERT_TRUE(engine_.SetOptions(parameters_options_all.options));
@ -2872,14 +2874,14 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
send_parameters_;
parameters_options_no_agc_nor_ns.options.auto_gain_control =
rtc::Maybe<bool>(false);
rtc::Optional<bool>(false);
parameters_options_no_agc_nor_ns.options.noise_suppression =
rtc::Maybe<bool>(false);
rtc::Optional<bool>(false);
channel2->SetSend(cricket::SEND_MICROPHONE);
channel2->SetSendParameters(parameters_options_no_agc_nor_ns);
expected_options.echo_cancellation = rtc::Maybe<bool>(true);
expected_options.auto_gain_control = rtc::Maybe<bool>(false);
expected_options.noise_suppression = rtc::Maybe<bool>(false);
expected_options.echo_cancellation = rtc::Optional<bool>(true);
expected_options.auto_gain_control = rtc::Optional<bool>(false);
expected_options.noise_suppression = rtc::Optional<bool>(false);
EXPECT_EQ(expected_options, channel2->options());
voe_.GetEcStatus(ec_enabled, ec_mode);
voe_.GetAgcStatus(agc_enabled, agc_mode);
@ -2898,13 +2900,13 @@ TEST_F(WebRtcVoiceEngineTestFake, TestSetDscpOptions) {
new cricket::FakeNetworkInterface);
channel->SetInterface(network_interface.get());
cricket::AudioSendParameters parameters = send_parameters_;
parameters.options.dscp = rtc::Maybe<bool>(true);
parameters.options.dscp = rtc::Optional<bool>(true);
EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
// Verify previous value is not modified if dscp option is not set.
EXPECT_TRUE(channel->SetSendParameters(send_parameters_));
EXPECT_EQ(rtc::DSCP_EF, network_interface->dscp());
parameters.options.dscp = rtc::Maybe<bool>(false);
parameters.options.dscp = rtc::Optional<bool>(false);
EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_EQ(rtc::DSCP_DEFAULT, network_interface->dscp());
}
@ -3013,7 +3015,7 @@ TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
}
// Enable combined BWE option - now it should be set up.
send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
send_parameters_.options.combined_audio_video_bwe = rtc::Optional<bool>(true);
EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
for (uint32_t ssrc : ssrcs) {
const auto* s = call_.GetAudioReceiveStream(ssrc);
@ -3022,7 +3024,8 @@ TEST_F(WebRtcVoiceEngineTestFake, CanChangeCombinedBweOption) {
}
// Disable combined BWE option - should be disabled again.
send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(false);
send_parameters_.options.combined_audio_video_bwe =
rtc::Optional<bool>(false);
EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
for (uint32_t ssrc : ssrcs) {
const auto* s = call_.GetAudioReceiveStream(ssrc);
@ -3039,7 +3042,7 @@ TEST_F(WebRtcVoiceEngineTestFake, ConfigureCombinedBweForNewRecvStreams) {
EXPECT_TRUE(SetupEngineWithSendStream());
cricket::WebRtcVoiceMediaChannel* media_channel =
static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
send_parameters_.options.combined_audio_video_bwe = rtc::Optional<bool>(true);
EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
static const uint32_t kSsrcs[] = {1, 2, 3, 4};
@ -3061,7 +3064,7 @@ TEST_F(WebRtcVoiceEngineTestFake, ConfiguresAudioReceiveStreamRtpExtensions) {
EXPECT_TRUE(SetupEngineWithSendStream());
cricket::WebRtcVoiceMediaChannel* media_channel =
static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
send_parameters_.options.combined_audio_video_bwe = rtc::Optional<bool>(true);
EXPECT_TRUE(media_channel->SetSendParameters(send_parameters_));
for (uint32_t ssrc : ssrcs) {
EXPECT_TRUE(media_channel->AddRecvStream(
@ -3120,7 +3123,7 @@ TEST_F(WebRtcVoiceEngineTestFake, DeliverAudioPacket_Call) {
EXPECT_TRUE(SetupEngineWithSendStream());
cricket::WebRtcVoiceMediaChannel* media_channel =
static_cast<cricket::WebRtcVoiceMediaChannel*>(channel_);
send_parameters_.options.combined_audio_video_bwe = rtc::Maybe<bool>(true);
send_parameters_.options.combined_audio_video_bwe = rtc::Optional<bool>(true);
EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
EXPECT_TRUE(media_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(kAudioSsrc)));

4
talk/session/media/channel.cc
View File

@ -1502,7 +1502,7 @@ bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
AudioSendParameters send_params = last_send_params_;
RtpSendParametersFromMediaDescription(audio, &send_params);
if (audio->agc_minus_10db()) {
send_params.options.adjust_agc_delta = rtc::Maybe<int>(kAgcMinus10db);
send_params.options.adjust_agc_delta = rtc::Optional<int>(kAgcMinus10db);
}
if (!media_channel()->SetSendParameters(send_params)) {
SafeSetError("Failed to set remote audio description send parameters.",
@ -1789,7 +1789,7 @@ bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
VideoSendParameters send_params = last_send_params_;
RtpSendParametersFromMediaDescription(video, &send_params);
if (video->conference_mode()) {
send_params.options.conference_mode = rtc::Maybe<bool>(true);
send_params.options.conference_mode = rtc::Optional<bool>(true);
}
if (!media_channel()->SetSendParameters(send_params)) {
SafeSetError("Failed to set remote video description send parameters.",

2
webrtc/base/BUILD.gn
View File

@ -115,11 +115,11 @@ static_library("rtc_base_approved") {
"event_tracer.h",
"exp_filter.cc",
"exp_filter.h",
"maybe.h",
"md5.cc",
"md5.h",
"md5digest.cc",
"md5digest.h",
"optional.h",
"platform_file.cc",
"platform_file.h",
"platform_thread.cc",

2
webrtc/base/base.gyp
View File

@ -54,11 +54,11 @@
'exp_filter.h',
'logging.cc',
'logging.h',
'maybe.h',
'md5.cc',
'md5.h',
'md5digest.cc',
'md5digest.h',
'optional.h',
'platform_file.cc',
'platform_file.h',
'platform_thread.cc',

2
webrtc/base/base_tests.gyp
View File

@ -71,13 +71,13 @@
'httpserver_unittest.cc',
'ipaddress_unittest.cc',
'logging_unittest.cc',
'maybe_unittest.cc',
'md5digest_unittest.cc',
'messagedigest_unittest.cc',
'messagequeue_unittest.cc',
'multipart_unittest.cc',
'nat_unittest.cc',
'network_unittest.cc',
'optional_unittest.cc',
'optionsfile_unittest.cc',
'pathutils_unittest.cc',
'profiler_unittest.cc',

66
webrtc/base/maybe.h → webrtc/base/optional.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_BASE_MAYBE_H_
#define WEBRTC_BASE_MAYBE_H_
#ifndef WEBRTC_BASE_OPTIONAL_H_
#define WEBRTC_BASE_OPTIONAL_H_
#include <algorithm>
#include <utility>
@ -24,38 +24,67 @@ namespace rtc {
// contain a value; use e.g. rtc::scoped_ptr<T> instead if that's too
// expensive.
//
// A moved-from Maybe<T> may only be destroyed, and assigned to if T allows
// A moved-from Optional<T> may only be destroyed, and assigned to if T allows
// being assigned to after having been moved from. Specifically, you may not
// assume that it just doesn't contain a value anymore.
//
// Examples of good places to use Optional:
//
// - As a class or struct member, when the member doesn't always have a value:
// struct Prisoner {
// std::string name;
// Optional<int> cell_number; // Empty if not currently incarcerated.
// };
//
// - As a return value for functions that may fail to return a value on all
// allowed inputs. For example, a function that searches an array might
// return an Optional<size_t> (the index where it found the element, or
// nothing if it didn't find it); and a function that parses numbers might
// return Optional<double> (the parsed number, or nothing if parsing failed).
//
// Examples of bad places to use Optional:
//
// - As a return value for functions that may fail because of disallowed
// inputs. For example, a string length function should not return
// Optional<size_t> so that it can return nothing in case the caller passed
// it a null pointer; the function should probably use RTC_[D]CHECK instead,
// and return plain size_t.
//
// - As a return value for functions that may fail to return a value on all
// allowed inputs, but need to tell the caller what went wrong. Returning
// Optional<double> when parsing a single number as in the example above
// might make sense, but any larger parse job is probably going to need to
// tell the caller what the problem was, not just that there was one.
//
// TODO(kwiberg): Get rid of this class when the standard library has
// std::optional (and we're allowed to use it).
template <typename T>
class Maybe final {
class Optional final {
public:
// Construct an empty Maybe.
Maybe() : has_value_(false) {}
// Construct an empty Optional.
Optional() : has_value_(false) {}
// Construct a Maybe that contains a value.
explicit Maybe(const T& val) : value_(val), has_value_(true) {}
explicit Maybe(T&& val) : value_(static_cast<T&&>(val)), has_value_(true) {}
// Construct an Optional that contains a value.
explicit Optional(const T& val) : value_(val), has_value_(true) {}
explicit Optional(T&& val)
: value_(static_cast<T&&>(val)), has_value_(true) {}
// Copy and move constructors.
// TODO(kwiberg): =default the move constructor when MSVC supports it.
Maybe(const Maybe&) = default;
Maybe(Maybe&& m)
Optional(const Optional&) = default;
Optional(Optional&& m)
: value_(static_cast<T&&>(m.value_)), has_value_(m.has_value_) {}
// Assignment.
// TODO(kwiberg): =default the move assignment op when MSVC supports it.
Maybe& operator=(const Maybe&) = default;
Maybe& operator=(Maybe&& m) {
Optional& operator=(const Optional&) = default;
Optional& operator=(Optional&& m) {
value_ = static_cast<T&&>(m.value_);
has_value_ = m.has_value_;
return *this;
}
friend void swap(Maybe& m1, Maybe& m2) {
friend void swap(Optional& m1, Optional& m2) {
using std::swap;
swap(m1.value_, m2.value_);
swap(m1.has_value_, m2.has_value_);
@ -87,13 +116,14 @@ class Maybe final {
return has_value_ ? value_ : default_val;
}
// Equality tests. Two Maybes are equal if they contain equivalent values, or
// Equality tests. Two Optionals are equal if they contain equivalent values,
// or
// if they're both empty.
friend bool operator==(const Maybe& m1, const Maybe& m2) {
friend bool operator==(const Optional& m1, const Optional& m2) {
return m1.has_value_ && m2.has_value_ ? m1.value_ == m2.value_
: m1.has_value_ == m2.has_value_;
}
friend bool operator!=(const Maybe& m1, const Maybe& m2) {
friend bool operator!=(const Optional& m1, const Optional& m2) {
return m1.has_value_ && m2.has_value_ ? m1.value_ != m2.value_
: m1.has_value_ != m2.has_value_;
}
@ -107,4 +137,4 @@ class Maybe final {
} // namespace rtc
#endif // WEBRTC_BASE_MAYBE_H_
#endif // WEBRTC_BASE_OPTIONAL_H_

132
webrtc/base/maybe_unittest.cc → webrtc/base/optional_unittest.cc
View File

@ -14,7 +14,7 @@
#include <vector>
#include "webrtc/base/gunit.h"
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
namespace rtc {
@ -118,19 +118,19 @@ std::vector<std::string> V(Ts... es) {
} // namespace
TEST(MaybeTest, TestConstructDefault) {
TEST(OptionalTest, TestConstructDefault) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Optional<Logger> x;
EXPECT_FALSE(x);
}
EXPECT_EQ(V("0:0. default constructor", "0:0. destructor"), *log);
}
TEST(MaybeTest, TestConstructCopyEmpty) {
TEST(OptionalTest, TestConstructCopyEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Optional<Logger> x;
EXPECT_FALSE(x);
auto y = x;
EXPECT_FALSE(y);
@ -140,11 +140,11 @@ TEST(MaybeTest, TestConstructCopyEmpty) {
*log);
}
TEST(MaybeTest, TestConstructCopyFull) {
TEST(OptionalTest, TestConstructCopyFull) {
auto log = Logger::Setup();
{
Logger a;
Maybe<Logger> x(a);
Optional<Logger> x(a);
EXPECT_TRUE(x);
log->push_back("---");
auto y = x;
@ -157,12 +157,12 @@ TEST(MaybeTest, TestConstructCopyFull) {
*log);
}
TEST(MaybeTest, TestConstructMoveEmpty) {
TEST(OptionalTest, TestConstructMoveEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Optional<Logger> x;
EXPECT_FALSE(x);
auto y = static_cast<Maybe<Logger>&&>(x);
auto y = static_cast<Optional<Logger>&&>(x);
EXPECT_FALSE(y);
}
EXPECT_EQ(V("0:0. default constructor", "1:0. move constructor (from 0:0)",
@ -170,13 +170,13 @@ TEST(MaybeTest, TestConstructMoveEmpty) {
*log);
}
TEST(MaybeTest, TestConstructMoveFull) {
TEST(OptionalTest, TestConstructMoveFull) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Optional<Logger> x(Logger(17));
EXPECT_TRUE(x);
log->push_back("---");
auto y = static_cast<Maybe<Logger>&&>(x);
auto y = static_cast<Optional<Logger>&&>(x);
EXPECT_TRUE(x);
EXPECT_TRUE(y);
log->push_back("---");
@ -188,10 +188,10 @@ TEST(MaybeTest, TestConstructMoveFull) {
*log);
}
TEST(MaybeTest, TestCopyAssignToEmptyFromEmpty) {
TEST(OptionalTest, TestCopyAssignToEmptyFromEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x, y;
Optional<Logger> x, y;
x = y;
}
EXPECT_EQ(
@ -200,11 +200,11 @@ TEST(MaybeTest, TestCopyAssignToEmptyFromEmpty) {
*log);
}
TEST(MaybeTest, TestCopyAssignToFullFromEmpty) {
TEST(OptionalTest, TestCopyAssignToFullFromEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Maybe<Logger> y;
Optional<Logger> x(Logger(17));
Optional<Logger> y;
log->push_back("---");
x = y;
log->push_back("---");
@ -217,11 +217,11 @@ TEST(MaybeTest, TestCopyAssignToFullFromEmpty) {
*log);
}
TEST(MaybeTest, TestCopyAssignToEmptyFromFull) {
TEST(OptionalTest, TestCopyAssignToEmptyFromFull) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Maybe<Logger> y(Logger(17));
Optional<Logger> x;
Optional<Logger> y(Logger(17));
log->push_back("---");
x = y;
log->push_back("---");
@ -233,11 +233,11 @@ TEST(MaybeTest, TestCopyAssignToEmptyFromFull) {
*log);
}
TEST(MaybeTest, TestCopyAssignToFullFromFull) {
TEST(OptionalTest, TestCopyAssignToFullFromFull) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Maybe<Logger> y(Logger(42));
Optional<Logger> x(Logger(17));
Optional<Logger> y(Logger(42));
log->push_back("---");
x = y;
log->push_back("---");
@ -251,13 +251,13 @@ TEST(MaybeTest, TestCopyAssignToFullFromFull) {
*log);
}
TEST(MaybeTest, TestCopyAssignToEmptyFromT) {
TEST(OptionalTest, TestCopyAssignToEmptyFromT) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Optional<Logger> x;
Logger y(17);
log->push_back("---");
x = rtc::Maybe<Logger>(y);
x = Optional<Logger>(y);
log->push_back("---");
}
EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", "---",
@ -267,13 +267,13 @@ TEST(MaybeTest, TestCopyAssignToEmptyFromT) {
*log);
}
TEST(MaybeTest, TestCopyAssignToFullFromT) {
TEST(OptionalTest, TestCopyAssignToFullFromT) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x = rtc::Maybe<Logger>(y);
x = Optional<Logger>(y);
log->push_back("---");
}
EXPECT_EQ(
@ -285,11 +285,11 @@ TEST(MaybeTest, TestCopyAssignToFullFromT) {
*log);
}
TEST(MaybeTest, TestMoveAssignToEmptyFromEmpty) {
TEST(OptionalTest, TestMoveAssignToEmptyFromEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x, y;
x = static_cast<Maybe<Logger>&&>(y);
Optional<Logger> x, y;
x = static_cast<Optional<Logger>&&>(y);
}
EXPECT_EQ(
V("0:0. default constructor", "1:1. default constructor",
@ -297,13 +297,13 @@ TEST(MaybeTest, TestMoveAssignToEmptyFromEmpty) {
*log);
}
TEST(MaybeTest, TestMoveAssignToFullFromEmpty) {
TEST(OptionalTest, TestMoveAssignToFullFromEmpty) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Maybe<Logger> y;
Optional<Logger> x(Logger(17));
Optional<Logger> y;
log->push_back("---");
x = static_cast<Maybe<Logger>&&>(y);
x = static_cast<Optional<Logger>&&>(y);
log->push_back("---");
}
EXPECT_EQ(
@ -314,13 +314,13 @@ TEST(MaybeTest, TestMoveAssignToFullFromEmpty) {
*log);
}
TEST(MaybeTest, TestMoveAssignToEmptyFromFull) {
TEST(OptionalTest, TestMoveAssignToEmptyFromFull) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Maybe<Logger> y(Logger(17));
Optional<Logger> x;
Optional<Logger> y(Logger(17));
log->push_back("---");
x = static_cast<Maybe<Logger>&&>(y);
x = static_cast<Optional<Logger>&&>(y);
log->push_back("---");
}
EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor",
@ -330,13 +330,13 @@ TEST(MaybeTest, TestMoveAssignToEmptyFromFull) {
*log);
}
TEST(MaybeTest, TestMoveAssignToFullFromFull) {
TEST(OptionalTest, TestMoveAssignToFullFromFull) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Maybe<Logger> y(Logger(42));
Optional<Logger> x(Logger(17));
Optional<Logger> y(Logger(42));
log->push_back("---");
x = static_cast<Maybe<Logger>&&>(y);
x = static_cast<Optional<Logger>&&>(y);
log->push_back("---");
}
EXPECT_EQ(
@ -348,13 +348,13 @@ TEST(MaybeTest, TestMoveAssignToFullFromFull) {
*log);
}
TEST(MaybeTest, TestMoveAssignToEmptyFromT) {
TEST(OptionalTest, TestMoveAssignToEmptyFromT) {
auto log = Logger::Setup();
{
Maybe<Logger> x;
Optional<Logger> x;
Logger y(17);
log->push_back("---");
x = rtc::Maybe<Logger>(static_cast<Logger&&>(y));
x = Optional<Logger>(static_cast<Logger&&>(y));
log->push_back("---");
}
EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", "---",
@ -364,13 +364,13 @@ TEST(MaybeTest, TestMoveAssignToEmptyFromT) {
*log);
}
TEST(MaybeTest, TestMoveAssignToFullFromT) {
TEST(OptionalTest, TestMoveAssignToFullFromT) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(17));
Optional<Logger> x(Logger(17));
Logger y(42);
log->push_back("---");
x = rtc::Maybe<Logger>(static_cast<Logger&&>(y));
x = Optional<Logger>(static_cast<Logger&&>(y));
log->push_back("---");
}
EXPECT_EQ(
@ -382,21 +382,21 @@ TEST(MaybeTest, TestMoveAssignToFullFromT) {
*log);
}
TEST(MaybeTest, TestDereference) {
TEST(OptionalTest, TestDereference) {
auto log = Logger::Setup();
{
Maybe<Logger> x(Logger(42));
Optional<Logger> x(Logger(42));
const auto& y = x;
log->push_back("---");
x->Foo();
y->Foo();
static_cast<Maybe<Logger>&&>(x)->Foo();
static_cast<const Maybe<Logger>&&>(y)->Foo();
static_cast<Optional<Logger>&&>(x)->Foo();
static_cast<const Optional<Logger>&&>(y)->Foo();
log->push_back("---");
(*x).Foo();
(*y).Foo();
(*static_cast<Maybe<Logger>&&>(x)).Foo();
(*static_cast<const Maybe<Logger>&&>(y)).Foo();
(*static_cast<Optional<Logger>&&>(x)).Foo();
(*static_cast<const Optional<Logger>&&>(y)).Foo();
log->push_back("---");
}
EXPECT_EQ(V("0:42. explicit constructor",
@ -407,20 +407,20 @@ TEST(MaybeTest, TestDereference) {
*log);
}
TEST(MaybeTest, TestDereferenceWithDefault) {
TEST(OptionalTest, TestDereferenceWithDefault) {
auto log = Logger::Setup();
{
const Logger a(17), b(42);
Maybe<Logger> x(a);
Maybe<Logger> y;
Optional<Logger> x(a);
Optional<Logger> y;
log->push_back("-1-");
EXPECT_EQ(a, x.value_or(Logger(42)));
log->push_back("-2-");
EXPECT_EQ(b, y.value_or(Logger(42)));
log->push_back("-3-");
EXPECT_EQ(a, Maybe<Logger>(Logger(17)).value_or(b));
EXPECT_EQ(a, Optional<Logger>(Logger(17)).value_or(b));
log->push_back("-4-");
EXPECT_EQ(b, Maybe<Logger>().value_or(b));
EXPECT_EQ(b, Optional<Logger>().value_or(b));
log->push_back("-5-");
}
EXPECT_EQ(
@ -437,11 +437,11 @@ TEST(MaybeTest, TestDereferenceWithDefault) {
*log);
}
TEST(MaybeTest, TestEquality) {
TEST(OptionalTest, TestEquality) {
auto log = Logger::Setup();
{
Logger a(17), b(42);
Maybe<Logger> ma1(a), ma2(a), mb(b), me1, me2;
Optional<Logger> ma1(a), ma2(a), mb(b), me1, me2;
log->push_back("---");
EXPECT_EQ(ma1, ma1);
EXPECT_EQ(ma1, ma2);
@ -463,11 +463,11 @@ TEST(MaybeTest, TestEquality) {
*log);
}
TEST(MaybeTest, TestSwap) {
TEST(OptionalTest, TestSwap) {
auto log = Logger::Setup();
{
Logger a(17), b(42);
Maybe<Logger> x1(a), x2(b), y1(a), y2, z1, z2;
Optional<Logger> x1(a), x2(b), y1(a), y2, z1, z2;
log->push_back("---");
swap(x1, x2); // Swap full <-> full.
swap(y1, y2); // Swap full <-> empty.

4
webrtc/modules/audio_coding/main/acm2/acm_receiver.cc
View File

@ -313,10 +313,10 @@ int32_t AcmReceiver::AddCodec(int acm_codec_id,
const auto neteq_decoder = [acm_codec_id, channels]() -> NetEqDecoder {
if (acm_codec_id == -1)
return NetEqDecoder::kDecoderArbitrary; // External decoder.
const rtc::Maybe<RentACodec::CodecId> cid =
const rtc::Optional<RentACodec::CodecId> cid =
RentACodec::CodecIdFromIndex(acm_codec_id);
RTC_DCHECK(cid) << "Invalid codec index: " << acm_codec_id;
const rtc::Maybe<NetEqDecoder> ned =
const rtc::Optional<NetEqDecoder> ned =
RentACodec::NetEqDecoderFromCodecId(*cid, channels);
RTC_DCHECK(ned) << "Invalid codec ID: " << static_cast<int>(*cid);
return *ned;

9
webrtc/modules/audio_coding/main/acm2/audio_coding_module.cc
View File

@ -57,7 +57,7 @@ int AudioCodingModule::Codec(const char* payload_name,
CodecInst* codec,
int sampling_freq_hz,
int channels) {
rtc::Maybe<CodecInst> ci = acm2::RentACodec::CodecInstByParams(
rtc::Optional<CodecInst> ci = acm2::RentACodec::CodecInstByParams(
payload_name, sampling_freq_hz, channels);
if (ci) {
*codec = *ci;
@ -77,11 +77,12 @@ int AudioCodingModule::Codec(const char* payload_name,
int AudioCodingModule::Codec(const char* payload_name,
int sampling_freq_hz,
int channels) {
rtc::Maybe<acm2::RentACodec::CodecId> ci = acm2::RentACodec::CodecIdByParams(
payload_name, sampling_freq_hz, channels);
rtc::Optional<acm2::RentACodec::CodecId> ci =
acm2::RentACodec::CodecIdByParams(payload_name, sampling_freq_hz,
channels);
if (!ci)
return -1;
rtc::Maybe<int> i = acm2::RentACodec::CodecIndexFromId(*ci);
rtc::Optional<int> i = acm2::RentACodec::CodecIndexFromId(*ci);
return i ? *i : -1;
}

2
webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
View File

@ -208,7 +208,7 @@ void AudioCodingModuleImpl::RegisterExternalSendCodec(
}
// Get current send codec.
rtc::Maybe<CodecInst> AudioCodingModuleImpl::SendCodec() const {
rtc::Optional<CodecInst> AudioCodingModuleImpl::SendCodec() const {
CriticalSectionScoped lock(acm_crit_sect_.get());
return codec_manager_.GetCodecInst();
}

2
webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h
View File

@ -47,7 +47,7 @@ class AudioCodingModuleImpl final : public AudioCodingModule {
AudioEncoder* external_speech_encoder) override;
// Get current send codec.
rtc::Maybe<CodecInst> SendCodec() const override;
rtc::Optional<CodecInst> SendCodec() const override;
// Get current send frequency.
int SendFrequency() const override;

6
webrtc/modules/audio_coding/main/acm2/codec_manager.cc
View File

@ -328,7 +328,7 @@ void CodecManager::RegisterEncoder(AudioEncoder* external_speech_encoder) {
codec_owner_.SetEncoders(external_speech_encoder, cng_pt, vad_mode_, red_pt);
}
rtc::Maybe<CodecInst> CodecManager::GetCodecInst() const {
rtc::Optional<CodecInst> CodecManager::GetCodecInst() const {
int dummy_id = 0;
WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
"SendCodec()");
@ -336,9 +336,9 @@ rtc::Maybe<CodecInst> CodecManager::GetCodecInst() const {
if (!codec_owner_.Encoder()) {
WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
"SendCodec Failed, no codec is registered");
return rtc::Maybe<CodecInst>();
return rtc::Optional<CodecInst>();
}
return rtc::Maybe<CodecInst>(send_codec_inst_);
return rtc::Optional<CodecInst>(send_codec_inst_);
}
bool CodecManager::SetCopyRed(bool enable) {

4
webrtc/modules/audio_coding/main/acm2/codec_manager.h
View File

@ -12,7 +12,7 @@
#define WEBRTC_MODULES_AUDIO_CODING_MAIN_ACM2_CODEC_MANAGER_H_
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/thread_checker.h"
#include "webrtc/modules/audio_coding/main/acm2/codec_owner.h"
@ -36,7 +36,7 @@ class CodecManager final {
void RegisterEncoder(AudioEncoder* external_speech_encoder);
rtc::Maybe<CodecInst> GetCodecInst() const;
rtc::Optional<CodecInst> GetCodecInst() const;
bool SetCopyRed(bool enable);

45
webrtc/modules/audio_coding/main/acm2/rent_a_codec.cc
View File

@ -36,7 +36,7 @@
namespace webrtc {
namespace acm2 {
rtc::Maybe<RentACodec::CodecId> RentACodec::CodecIdByParams(
rtc::Optional<RentACodec::CodecId> RentACodec::CodecIdByParams(
const char* payload_name,
int sampling_freq_hz,
int channels) {
@ -44,24 +44,25 @@ rtc::Maybe<RentACodec::CodecId> RentACodec::CodecIdByParams(
ACMCodecDB::CodecId(payload_name, sampling_freq_hz, channels));
}
rtc::Maybe<CodecInst> RentACodec::CodecInstById(CodecId codec_id) {
rtc::Maybe<int> mi = CodecIndexFromId(codec_id);
return mi ? rtc::Maybe<CodecInst>(Database()[*mi]) : rtc::Maybe<CodecInst>();
rtc::Optional<CodecInst> RentACodec::CodecInstById(CodecId codec_id) {
rtc::Optional<int> mi = CodecIndexFromId(codec_id);
return mi ? rtc::Optional<CodecInst>(Database()[*mi])
: rtc::Optional<CodecInst>();
}
rtc::Maybe<RentACodec::CodecId> RentACodec::CodecIdByInst(
rtc::Optional<RentACodec::CodecId> RentACodec::CodecIdByInst(
const CodecInst& codec_inst) {
return CodecIdFromIndex(ACMCodecDB::CodecNumber(codec_inst));
}
rtc::Maybe<CodecInst> RentACodec::CodecInstByParams(const char* payload_name,
int sampling_freq_hz,
int channels) {
rtc::Maybe<CodecId> codec_id =
rtc::Optional<CodecInst> RentACodec::CodecInstByParams(const char* payload_name,
int sampling_freq_hz,
int channels) {
rtc::Optional<CodecId> codec_id =
CodecIdByParams(payload_name, sampling_freq_hz, channels);
if (!codec_id)
return rtc::Maybe<CodecInst>();
rtc::Maybe<CodecInst> ci = CodecInstById(*codec_id);
return rtc::Optional<CodecInst>();
rtc::Optional<CodecInst> ci = CodecInstById(*codec_id);
RTC_DCHECK(ci);
// Keep the number of channels from the function call. For most codecs it
@ -75,12 +76,13 @@ bool RentACodec::IsCodecValid(const CodecInst& codec_inst) {
return ACMCodecDB::CodecNumber(codec_inst) >= 0;
}
rtc::Maybe<bool> RentACodec::IsSupportedNumChannels(CodecId codec_id,
int num_channels) {
rtc::Optional<bool> RentACodec::IsSupportedNumChannels(CodecId codec_id,
int num_channels) {
auto i = CodecIndexFromId(codec_id);
return i ? rtc::Maybe<bool>(ACMCodecDB::codec_settings_[*i].channel_support >=
num_channels)
: rtc::Maybe<bool>();
return i ? rtc::Optional<bool>(
ACMCodecDB::codec_settings_[*i].channel_support >=
num_channels)
: rtc::Optional<bool>();
}
rtc::ArrayView<const CodecInst> RentACodec::Database() {
@ -88,13 +90,14 @@ rtc::ArrayView<const CodecInst> RentACodec::Database() {
NumberOfCodecs());
}
rtc::Maybe<NetEqDecoder> RentACodec::NetEqDecoderFromCodecId(CodecId codec_id,
int num_channels) {
rtc::Maybe<int> i = CodecIndexFromId(codec_id);
rtc::Optional<NetEqDecoder> RentACodec::NetEqDecoderFromCodecId(
CodecId codec_id,
int num_channels) {
rtc::Optional<int> i = CodecIndexFromId(codec_id);
if (!i)
return rtc::Maybe<NetEqDecoder>();
return rtc::Optional<NetEqDecoder>();
const NetEqDecoder ned = ACMCodecDB::neteq_decoders_[*i];
return rtc::Maybe<NetEqDecoder>(
return rtc::Optional<NetEqDecoder>(
(ned == NetEqDecoder::kDecoderOpus && num_channels == 2)
? NetEqDecoder::kDecoderOpus_2ch
: ned);

39
webrtc/modules/audio_coding/main/acm2/rent_a_codec.h
View File

@ -15,7 +15,7 @@
#include "webrtc/base/array_view.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/typedefs.h"
#include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
@ -144,27 +144,28 @@ class RentACodec {
return static_cast<size_t>(CodecId::kNumCodecs);
}
static inline rtc::Maybe<int> CodecIndexFromId(CodecId codec_id) {
static inline rtc::Optional<int> CodecIndexFromId(CodecId codec_id) {
const int i = static_cast<int>(codec_id);
return i >= 0 && i < static_cast<int>(NumberOfCodecs()) ? rtc::Maybe<int>(i)
: rtc::Maybe<int>();
return i >= 0 && i < static_cast<int>(NumberOfCodecs())
? rtc::Optional<int>(i)
: rtc::Optional<int>();
}
static inline rtc::Maybe<CodecId> CodecIdFromIndex(int codec_index) {
static inline rtc::Optional<CodecId> CodecIdFromIndex(int codec_index) {
return static_cast<size_t>(codec_index) < NumberOfCodecs()
? rtc::Maybe<RentACodec::CodecId>(
? rtc::Optional<RentACodec::CodecId>(
static_cast<RentACodec::CodecId>(codec_index))
: rtc::Maybe<RentACodec::CodecId>();
: rtc::Optional<RentACodec::CodecId>();
}
static rtc::Maybe<CodecId> CodecIdByParams(const char* payload_name,
int sampling_freq_hz,
int channels);
static rtc::Maybe<CodecInst> CodecInstById(CodecId codec_id);
static rtc::Maybe<CodecId> CodecIdByInst(const CodecInst& codec_inst);
static rtc::Maybe<CodecInst> CodecInstByParams(const char* payload_name,
int sampling_freq_hz,
int channels);
static rtc::Optional<CodecId> CodecIdByParams(const char* payload_name,
int sampling_freq_hz,
int channels);
static rtc::Optional<CodecInst> CodecInstById(CodecId codec_id);
static rtc::Optional<CodecId> CodecIdByInst(const CodecInst& codec_inst);
static rtc::Optional<CodecInst> CodecInstByParams(const char* payload_name,
int sampling_freq_hz,
int channels);
static bool IsCodecValid(const CodecInst& codec_inst);
static inline bool IsPayloadTypeValid(int payload_type) {
@ -173,11 +174,11 @@ class RentACodec {
static rtc::ArrayView<const CodecInst> Database();
static rtc::Maybe<bool> IsSupportedNumChannels(CodecId codec_id,
int num_channels);
static rtc::Optional<bool> IsSupportedNumChannels(CodecId codec_id,
int num_channels);
static rtc::Maybe<NetEqDecoder> NetEqDecoderFromCodecId(CodecId codec_id,
int num_channels);
static rtc::Optional<NetEqDecoder> NetEqDecoderFromCodecId(CodecId codec_id,
int num_channels);
RentACodec();
~RentACodec();

4
webrtc/modules/audio_coding/main/include/audio_coding_module.h
View File

@ -13,7 +13,7 @@
#include <vector>
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/audio_coding/main/include/audio_coding_module_typedefs.h"
#include "webrtc/modules/audio_coding/neteq/include/neteq.h"
@ -213,7 +213,7 @@ class AudioCodingModule {
// Return value:
// The send codec, or nothing if we don't have one
//
virtual rtc::Maybe<CodecInst> SendCodec() const = 0;
virtual rtc::Optional<CodecInst> SendCodec() const = 0;
///////////////////////////////////////////////////////////////////////////
// int32_t SendFrequency()

2
webrtc/modules/audio_coding/main/test/APITest.cc
View File

@ -827,7 +827,7 @@ void APITest::TestRegisteration(char sendSide) {
if (!myCodec) {
CodecInst ci;
AudioCodingModule::Codec(_codecCntrA, &ci);
myCodec = rtc::Maybe<CodecInst>(ci);
myCodec = rtc::Optional<CodecInst>(ci);
}
if (!_randomTest) {

25
webrtc/modules/audio_processing/beamformer/array_util.cc
View File

@ -56,7 +56,7 @@ bool ArePerpendicular(const Point& a, const Point& b) {
return std::abs(DotProduct(a, b)) < kMaxDotProduct;
}
rtc::Maybe<Point> GetDirectionIfLinear(
rtc::Optional<Point> GetDirectionIfLinear(
const std::vector<Point>& array_geometry) {
RTC_DCHECK_GT(array_geometry.size(), 1u);
const Point first_pair_direction =
@ -65,13 +65,14 @@ rtc::Maybe<Point> GetDirectionIfLinear(
const Point pair_direction =
PairDirection(array_geometry[i - 1], array_geometry[i]);
if (!AreParallel(first_pair_direction, pair_direction)) {
return rtc::Maybe<Point>();
return rtc::Optional<Point>();
}
}
return rtc::Maybe<Point>(first_pair_direction);
return rtc::Optional<Point>(first_pair_direction);
}
rtc::Maybe<Point> GetNormalIfPlanar(const std::vector<Point>& array_geometry) {
rtc::Optional<Point> GetNormalIfPlanar(
const std::vector<Point>& array_geometry) {
RTC_DCHECK_GT(array_geometry.size(), 1u);
const Point first_pair_direction =
PairDirection(array_geometry[0], array_geometry[1]);
@ -85,30 +86,30 @@ rtc::Maybe<Point> GetNormalIfPlanar(const std::vector<Point>& array_geometry) {
}
}
if (is_linear) {
return rtc::Maybe<Point>();
return rtc::Optional<Point>();
}
const Point normal_direction =
CrossProduct(first_pair_direction, pair_direction);
for (; i < array_geometry.size(); ++i) {
pair_direction = PairDirection(array_geometry[i - 1], array_geometry[i]);
if (!ArePerpendicular(normal_direction, pair_direction)) {
return rtc::Maybe<Point>();
return rtc::Optional<Point>();
}
}
return rtc::Maybe<Point>(normal_direction);
return rtc::Optional<Point>(normal_direction);
}
rtc::Maybe<Point> GetArrayNormalIfExists(
rtc::Optional<Point> GetArrayNormalIfExists(
const std::vector<Point>& array_geometry) {
const rtc::Maybe<Point> direction = GetDirectionIfLinear(array_geometry);
const rtc::Optional<Point> direction = GetDirectionIfLinear(array_geometry);
if (direction) {
return rtc::Maybe<Point>(Point(direction->y(), -direction->x(), 0.f));
return rtc::Optional<Point>(Point(direction->y(), -direction->x(), 0.f));
}
const rtc::Maybe<Point> normal = GetNormalIfPlanar(array_geometry);
const rtc::Optional<Point> normal = GetNormalIfPlanar(array_geometry);
if (normal && normal->z() < kMaxDotProduct) {
return normal;
}
return rtc::Maybe<Point>();
return rtc::Optional<Point>();
}
Point AzimuthToPoint(float azimuth) {

9
webrtc/modules/audio_processing/beamformer/array_util.h
View File

@ -14,7 +14,7 @@
#include <cmath>
#include <vector>
#include "webrtc/base/maybe.h"
#include "webrtc/base/optional.h"
namespace webrtc {
@ -59,15 +59,16 @@ float GetMinimumSpacing(const std::vector<Point>& array_geometry);
// If the given array geometry is linear it returns the direction without
// normalizing.
rtc::Maybe<Point> GetDirectionIfLinear(
rtc::Optional<Point> GetDirectionIfLinear(
const std::vector<Point>& array_geometry);
// If the given array geometry is planar it returns the normal without
// normalizing.
rtc::Maybe<Point> GetNormalIfPlanar(const std::vector<Point>& array_geometry);
rtc::Optional<Point> GetNormalIfPlanar(
const std::vector<Point>& array_geometry);
// Returns the normal of an array if it has one and it is in the xy-plane.
rtc::Maybe<Point> GetArrayNormalIfExists(
rtc::Optional<Point> GetArrayNormalIfExists(
const std::vector<Point>& array_geometry);
// The resulting Point will be in the xy-plane.

2
webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.h
View File

@ -134,7 +134,7 @@ class NonlinearBeamformer
const std::vector<Point> array_geometry_;
// The normal direction of the array if it has one and it is in the xy-plane.
const rtc::Maybe<Point> array_normal_;
const rtc::Optional<Point> array_normal_;
// Minimum spacing between microphone pairs.
const float min_mic_spacing_;