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 /media

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.

TBR=pthatcher@webrtc.org

Bug: None
Change-Id: I6dd8677a65f897877fc848aefa7ab37d844e70ed
Reviewed-on: https://webrtc-review.googlesource.com/23573
Commit-Queue: Oskar Sundbom <ossu@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20816}
This commit is contained in:
Oskar Sundbom
2017-11-16 11:09:55 +01:00
committed by Commit Bot
parent 872cf38c4d
commit 7880758b90
15 changed files with 252 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
media/base/adaptedvideotracksource.cc
View File

@ -95,7 +95,7 @@ bool AdaptedVideoTrackSource::AdaptFrame(int width,
int* crop_y) {
{
rtc::CritScope lock(&stats_crit_);
stats_ = rtc::Optional<Stats>({width, height});
stats_ = Stats{width, height};
}
if (!broadcaster_.frame_wanted()) {

4
media/base/codec.cc
View File

@ -152,7 +152,7 @@ webrtc::RtpCodecParameters Codec::ToCodecParameters() const {
webrtc::RtpCodecParameters codec_params;
codec_params.payload_type = id;
codec_params.name = name;
codec_params.clock_rate = rtc::Optional<int>(clockrate);
codec_params.clock_rate = clockrate;
return codec_params;
}
@ -201,7 +201,7 @@ std::string AudioCodec::ToString() const {
webrtc::RtpCodecParameters AudioCodec::ToCodecParameters() const {
webrtc::RtpCodecParameters codec_params = Codec::ToCodecParameters();
codec_params.num_channels = rtc::Optional<int>(static_cast<int>(channels));
codec_params.num_channels = static_cast<int>(channels);
codec_params.kind = MEDIA_TYPE_AUDIO;
return codec_params;
}

9
media/base/codec_unittest.cc
View File

@ -313,15 +313,14 @@ TEST(CodecTest, TestToCodecParameters) {
EXPECT_EQ(96, codec_params_1.payload_type);
EXPECT_EQ(cricket::MEDIA_TYPE_VIDEO, codec_params_1.kind);
EXPECT_EQ("V", codec_params_1.name);
EXPECT_EQ(rtc::Optional<int>(cricket::kVideoCodecClockrate),
codec_params_1.clock_rate);
EXPECT_EQ(rtc::Optional<int>(), codec_params_1.num_channels);
EXPECT_EQ(cricket::kVideoCodecClockrate, codec_params_1.clock_rate);
EXPECT_EQ(rtc::nullopt, codec_params_1.num_channels);
const AudioCodec a(97, "A", 44100, 20000, 2);
webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
EXPECT_EQ(97, codec_params_2.payload_type);
EXPECT_EQ(cricket::MEDIA_TYPE_AUDIO, codec_params_2.kind);
EXPECT_EQ("A", codec_params_2.name);
EXPECT_EQ(rtc::Optional<int>(44100), codec_params_2.clock_rate);
EXPECT_EQ(rtc::Optional<int>(2), codec_params_2.num_channels);
EXPECT_EQ(44100, codec_params_2.clock_rate);
EXPECT_EQ(2, codec_params_2.num_channels);
}

28
media/base/h264_profile_level_id.cc
View File

@ -121,10 +121,10 @@ static constexpr LevelConstraint kLevelConstraints[] = {
rtc::Optional<ProfileLevelId> ParseProfileLevelId(const char* str) {
// The string should consist of 3 bytes in hexadecimal format.
if (strlen(str) != 6u)
return rtc::Optional<ProfileLevelId>();
return rtc::nullopt;
const uint32_t profile_level_id_numeric = strtol(str, nullptr, 16);
if (profile_level_id_numeric == 0)
return rtc::Optional<ProfileLevelId>();
return rtc::nullopt;
// Separate into three bytes.
const uint8_t level_idc =
@ -159,19 +159,19 @@ rtc::Optional<ProfileLevelId> ParseProfileLevelId(const char* str) {
break;
default:
// Unrecognized level_idc.
return rtc::Optional<ProfileLevelId>();
return rtc::nullopt;
}
// Parse profile_idc/profile_iop into a Profile enum.
for (const ProfilePattern& pattern : kProfilePatterns) {
if (profile_idc == pattern.profile_idc &&
pattern.profile_iop.IsMatch(profile_iop)) {
return rtc::Optional<ProfileLevelId>({pattern.profile, level});
return ProfileLevelId(pattern.profile, level);
}
}
// Unrecognized profile_idc/profile_iop combination.
return rtc::Optional<ProfileLevelId>();
return rtc::nullopt;
}
rtc::Optional<Level> SupportedLevel(int max_frame_pixel_count, float max_fps) {
@ -183,12 +183,12 @@ rtc::Optional<Level> SupportedLevel(int max_frame_pixel_count, float max_fps) {
max_frame_pixel_count &&
level_constraint.max_macroblocks_per_second <=
max_fps * level_constraint.max_macroblock_frame_size) {
return rtc::Optional<Level>(level_constraint.level);
return level_constraint.level;
}
}
// No level supported.
return rtc::Optional<Level>();
return rtc::nullopt;
}
rtc::Optional<ProfileLevelId> ParseSdpProfileLevelId(
@ -205,7 +205,7 @@ rtc::Optional<ProfileLevelId> ParseSdpProfileLevelId(
const auto profile_level_id_it = params.find(kProfileLevelId);
return (profile_level_id_it == params.end())
? rtc::Optional<ProfileLevelId>(kDefaultProfileLevelId)
? kDefaultProfileLevelId
: ParseProfileLevelId(profile_level_id_it->second.c_str());
}
@ -215,14 +215,14 @@ rtc::Optional<std::string> ProfileLevelIdToString(
if (profile_level_id.level == kLevel1_b) {
switch (profile_level_id.profile) {
case kProfileConstrainedBaseline:
return rtc::Optional<std::string>("42f00b");
return {"42f00b"};
case kProfileBaseline:
return rtc::Optional<std::string>("42100b");
return {"42100b"};
case kProfileMain:
return rtc::Optional<std::string>("4d100b");
return {"4d100b"};
// Level 1b is not allowed for other profiles.
default:
return rtc::Optional<std::string>();
return rtc::nullopt;
}
}
@ -245,12 +245,12 @@ rtc::Optional<std::string> ProfileLevelIdToString(
break;
// Unrecognized profile.
default:
return rtc::Optional<std::string>();
return rtc::nullopt;
}
char str[7];
snprintf(str, 7u, "%s%02x", profile_idc_iop_string, profile_level_id.level);
return rtc::Optional<std::string>(str);
return {str};
}
// Set level according to https://tools.ietf.org/html/rfc6184#section-8.2.2.

7
media/base/videoadapter.cc
View File

@ -151,8 +151,7 @@ bool VideoAdapter::KeepFrame(int64_t in_timestamp_ns) {
// First timestamp received or timestamp is way outside expected range, so
// reset. Set first timestamp target to just half the interval to prefer
// keeping frames in case of jitter.
next_frame_timestamp_ns_ =
rtc::Optional<int64_t>(in_timestamp_ns + frame_interval_ns / 2);
next_frame_timestamp_ns_ = in_timestamp_ns + frame_interval_ns / 2;
return true;
}
@ -258,8 +257,8 @@ bool VideoAdapter::AdaptFrameResolution(int in_width,
void VideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
rtc::CritScope cs(&critical_section_);
requested_format_ = rtc::Optional<VideoFormat>(format);
next_frame_timestamp_ns_ = rtc::Optional<int64_t>();
requested_format_ = format;
next_frame_timestamp_ns_ = rtc::nullopt;
}
void VideoAdapter::OnResolutionFramerateRequest(

64
media/base/videoadapter_unittest.cc
View File

@ -391,7 +391,7 @@ TEST_F(VideoAdapterTest, AdaptFramerateOntheFly) {
// Do not adapt the frame rate or the resolution. Expect no frame drop, no
// cropping, and no resolution change.
TEST_F(VideoAdapterTest, OnFramerateRequestMax) {
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
adapter_.OnResolutionFramerateRequest(rtc::nullopt,
std::numeric_limits<int>::max(),
std::numeric_limits<int>::max());
@ -409,7 +409,7 @@ TEST_F(VideoAdapterTest, OnFramerateRequestMax) {
}
TEST_F(VideoAdapterTest, OnFramerateRequestZero) {
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
adapter_.OnResolutionFramerateRequest(rtc::nullopt,
std::numeric_limits<int>::max(), 0);
EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
for (int i = 0; i < 10; ++i)
@ -425,7 +425,7 @@ TEST_F(VideoAdapterTest, OnFramerateRequestZero) {
// the number of dropped frames to be half of the number the captured frames.
TEST_F(VideoAdapterTest, OnFramerateRequestHalf) {
adapter_.OnResolutionFramerateRequest(
rtc::Optional<int>(), std::numeric_limits<int>::max(), kDefaultFps / 2);
rtc::nullopt, std::numeric_limits<int>::max(), kDefaultFps / 2);
EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
for (int i = 0; i < 10; ++i)
capturer_->CaptureFrame();
@ -750,7 +750,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(720, out_height_);
// Adapt down one step.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 1280 * 720 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 1280 * 720 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -761,7 +761,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(540, out_height_);
// Adapt down one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 960 * 540 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 960 * 540 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -772,7 +772,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(360, out_height_);
// Adapt down one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 360 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -783,7 +783,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(270, out_height_);
// Adapt up one step.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(640 * 360),
adapter_.OnResolutionFramerateRequest(640 * 360,
960 * 540,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
@ -795,7 +795,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(360, out_height_);
// Adapt up one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
adapter_.OnResolutionFramerateRequest(960 * 540,
1280 * 720,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
@ -807,7 +807,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInSmallSteps) {
EXPECT_EQ(540, out_height_);
// Adapt up one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(1280 * 720),
adapter_.OnResolutionFramerateRequest(1280 * 720,
1920 * 1080,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
@ -828,7 +828,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestMaxZero) {
EXPECT_EQ(1280, out_width_);
EXPECT_EQ(720, out_height_);
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 0,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 0,
std::numeric_limits<int>::max());
EXPECT_FALSE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -837,7 +837,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestMaxZero) {
TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
// Large step down.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 360 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -848,8 +848,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
EXPECT_EQ(270, out_height_);
// Large step up.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(1280 * 720),
1920 * 1080,
adapter_.OnResolutionFramerateRequest(1280 * 720, 1920 * 1080,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -861,7 +860,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
}
TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) {
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 360 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -881,7 +880,7 @@ TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) {
EXPECT_EQ(480, out_width_);
EXPECT_EQ(270, out_height_);
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 960 * 720,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 960 * 720,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -901,7 +900,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) {
EXPECT_EQ(1280, out_width_);
EXPECT_EQ(720, out_height_);
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 360 - 1,
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
&cropped_width_, &cropped_height_,
@ -911,7 +910,7 @@ TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) {
EXPECT_EQ(480, out_width_);
EXPECT_EQ(270, out_height_);
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
adapter_.OnResolutionFramerateRequest(rtc::nullopt,
std::numeric_limits<int>::max(),
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
@ -937,7 +936,7 @@ TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
EXPECT_EQ(360, out_height_);
// Adapt down one step.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 360 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 360 - 1,
std::numeric_limits<int>::max());
// Expect cropping to 16:9 format and 3/4 scaling.
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
@ -949,7 +948,7 @@ TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
EXPECT_EQ(270, out_height_);
// Adapt down one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 480 * 270 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 480 * 270 - 1,
std::numeric_limits<int>::max());
// Expect cropping to 16:9 format and 1/2 scaling.
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
@ -961,8 +960,7 @@ TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
EXPECT_EQ(180, out_height_);
// Adapt up one step.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(480 * 270),
640 * 360,
adapter_.OnResolutionFramerateRequest(480 * 270, 640 * 360,
std::numeric_limits<int>::max());
// Expect cropping to 16:9 format and 3/4 scaling.
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
@ -974,8 +972,7 @@ TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
EXPECT_EQ(270, out_height_);
// Adapt up one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(640 * 360),
960 * 540,
adapter_.OnResolutionFramerateRequest(640 * 360, 960 * 540,
std::numeric_limits<int>::max());
// Expect cropping to 16:9 format and no scaling.
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
@ -987,8 +984,7 @@ TEST_F(VideoAdapterTest, TestCroppingWithResolutionRequest) {
EXPECT_EQ(360, out_height_);
// Try to adapt up one step more.
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
1280 * 720,
adapter_.OnResolutionFramerateRequest(960 * 540, 1280 * 720,
std::numeric_limits<int>::max());
// Expect cropping to 16:9 format and no scaling.
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
@ -1004,7 +1000,7 @@ TEST_F(VideoAdapterTest, TestCroppingOddResolution) {
// Ask for 640x360 (16:9 aspect), with 3/16 scaling.
adapter_.OnOutputFormatRequest(
VideoFormat(640, 360, 0, FOURCC_I420));
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
adapter_.OnResolutionFramerateRequest(rtc::nullopt,
640 * 360 * 3 / 16 * 3 / 16,
std::numeric_limits<int>::max());
@ -1026,7 +1022,7 @@ TEST_F(VideoAdapterTest, TestAdaptToVerySmallResolution) {
const int w = 1920;
const int h = 1080;
adapter_.OnOutputFormatRequest(VideoFormat(w, h, 0, FOURCC_I420));
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(),
adapter_.OnResolutionFramerateRequest(rtc::nullopt,
w * h * 1 / 16 * 1 / 16,
std::numeric_limits<int>::max());
@ -1042,8 +1038,8 @@ TEST_F(VideoAdapterTest, TestAdaptToVerySmallResolution) {
EXPECT_EQ(67, out_height_);
// Adapt back up one step to 3/32.
adapter_.OnResolutionFramerateRequest(
rtc::Optional<int>(w * h * 3 / 32 * 3 / 32), w * h * 1 / 8 * 1 / 8,
adapter_.OnResolutionFramerateRequest(w * h * 3 / 32 * 3 / 32,
w * h * 1 / 8 * 1 / 8,
std::numeric_limits<int>::max());
// Send 1920x1080 (16:9 aspect).
@ -1064,7 +1060,7 @@ TEST_F(VideoAdapterTest, AdaptFrameResolutionDropWithResolutionRequest) {
&cropped_width_, &cropped_height_,
&out_width_, &out_height_));
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(960 * 540),
adapter_.OnResolutionFramerateRequest(960 * 540,
std::numeric_limits<int>::max(),
std::numeric_limits<int>::max());
@ -1074,7 +1070,7 @@ TEST_F(VideoAdapterTest, AdaptFrameResolutionDropWithResolutionRequest) {
&cropped_width_, &cropped_height_,
&out_width_, &out_height_));
adapter_.OnResolutionFramerateRequest(rtc::Optional<int>(), 640 * 480 - 1,
adapter_.OnResolutionFramerateRequest(rtc::nullopt, 640 * 480 - 1,
std::numeric_limits<int>::max());
// Still expect all frames to be dropped
@ -1087,9 +1083,9 @@ TEST_F(VideoAdapterTest, AdaptFrameResolutionDropWithResolutionRequest) {
// Test that we will adapt to max given a target pixel count close to max.
TEST_F(VideoAdapterTest, TestAdaptToMax) {
adapter_.OnOutputFormatRequest(VideoFormat(640, 360, 0, FOURCC_I420));
adapter_.OnResolutionFramerateRequest(
rtc::Optional<int>(640 * 360 - 1) /* target */,
std::numeric_limits<int>::max(), std::numeric_limits<int>::max());
adapter_.OnResolutionFramerateRequest(640 * 360 - 1 /* target */,
std::numeric_limits<int>::max(),
std::numeric_limits<int>::max());
EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 360, 0, &cropped_width_,
&cropped_height_, &out_width_,

4
media/base/videobroadcaster_unittest.cc
View File

@ -115,14 +115,14 @@ TEST(VideoBroadcasterTest, AppliesMinOfSinkWantsMaxAndTargetPixelCount) {
FakeVideoRenderer sink1;
VideoSinkWants wants1;
wants1.target_pixel_count = rtc::Optional<int>(1280 * 720);
wants1.target_pixel_count = 1280 * 720;
broadcaster.AddOrUpdateSink(&sink1, wants1);
EXPECT_EQ(1280 * 720, *broadcaster.wants().target_pixel_count);
FakeVideoRenderer sink2;
VideoSinkWants wants2;
wants2.target_pixel_count = rtc::Optional<int>(640 * 360);
wants2.target_pixel_count = 640 * 360;
broadcaster.AddOrUpdateSink(&sink2, wants2);
EXPECT_EQ(640 * 360, *broadcaster.wants().target_pixel_count);

2
media/base/videoengine_unittest.h
View File

@ -767,7 +767,7 @@ class VideoMediaChannelTest : public testing::Test,
// screencast. It's unclear why, I see nothing obvious in this
// test which is related to screencast logic.
cricket::VideoOptions video_options;
video_options.is_screencast = rtc::Optional<bool>(true);
video_options.is_screencast = true;
channel_->SetVideoSend(kSsrc, true, &video_options, nullptr);
cricket::VideoFormat format(480, 360,

2
media/engine/fakewebrtccall.cc
View File

@ -189,7 +189,7 @@ void FakeVideoSendStream::OnFrame(const webrtc::VideoFrame& frame) {
video_streams_ = encoder_config_.video_stream_factory->CreateEncoderStreams(
frame.width(), frame.height(), encoder_config_);
}
last_frame_ = rtc::Optional<webrtc::VideoFrame>(frame);
last_frame_ = frame;
}
void FakeVideoSendStream::SetStats(

14
media/engine/payload_type_mapper.cc
View File

@ -89,7 +89,7 @@ rtc::Optional<int> PayloadTypeMapper::GetMappingFor(
const webrtc::SdpAudioFormat& format) {
auto iter = mappings_.find(format);
if (iter != mappings_.end())
return rtc::Optional<int>(iter->second);
return iter->second;
for (; next_unused_payload_type_ <= max_payload_type_;
++next_unused_payload_type_) {
@ -98,20 +98,20 @@ rtc::Optional<int> PayloadTypeMapper::GetMappingFor(
used_payload_types_.insert(payload_type);
mappings_[format] = payload_type;
++next_unused_payload_type_;
return rtc::Optional<int>(payload_type);
return payload_type;
}
}
return rtc::Optional<int>();
return rtc::nullopt;
}
rtc::Optional<int> PayloadTypeMapper::FindMappingFor(
const webrtc::SdpAudioFormat& format) const {
auto iter = mappings_.find(format);
if (iter != mappings_.end())
return rtc::Optional<int>(iter->second);
return iter->second;
return rtc::Optional<int>();
return rtc::nullopt;
}
rtc::Optional<AudioCodec> PayloadTypeMapper::ToAudioCodec(
@ -126,10 +126,10 @@ rtc::Optional<AudioCodec> PayloadTypeMapper::ToAudioCodec(
AudioCodec codec(*opt_payload_type, format.name, format.clockrate_hz, 0,
format.num_channels);
codec.params = format.parameters;
return rtc::Optional<AudioCodec>(std::move(codec));
return std::move(codec);
}
return rtc::Optional<AudioCodec>();
return rtc::nullopt;
}
bool PayloadTypeMapper::SdpAudioFormatOrdering::operator()(

79
media/engine/payload_type_mapper_unittest.cc
View File

@ -17,70 +17,53 @@
namespace cricket {
class PayloadTypeMapperTest : public testing::Test {
public:
// TODO(ossu): These are to work around missing comparison operators in
// rtc::Optional. They should be removed once Optional has been updated.
int FindMapping(const webrtc::SdpAudioFormat& format) {
auto opt_mapping = mapper_.FindMappingFor(format);
if (opt_mapping)
return *opt_mapping;
return -1;
}
int GetMapping(const webrtc::SdpAudioFormat& format) {
auto opt_mapping = mapper_.GetMappingFor(format);
if (opt_mapping)
return *opt_mapping;
return -1;
}
protected:
PayloadTypeMapper mapper_;
};
TEST_F(PayloadTypeMapperTest, StaticPayloadTypes) {
EXPECT_EQ(0, FindMapping({"pcmu", 8000, 1}));
EXPECT_EQ(3, FindMapping({"gsm", 8000, 1}));
EXPECT_EQ(4, FindMapping({"g723", 8000, 1}));
EXPECT_EQ(5, FindMapping({"dvi4", 8000, 1}));
EXPECT_EQ(6, FindMapping({"dvi4", 16000, 1}));
EXPECT_EQ(7, FindMapping({"lpc", 8000, 1}));
EXPECT_EQ(8, FindMapping({"pcma", 8000, 1}));
EXPECT_EQ(9, FindMapping({"g722", 8000, 1}));
EXPECT_EQ(10, FindMapping({"l16", 44100, 2}));
EXPECT_EQ(11, FindMapping({"l16", 44100, 1}));
EXPECT_EQ(12, FindMapping({"qcelp", 8000, 1}));
EXPECT_EQ(13, FindMapping({"cn", 8000, 1}));
EXPECT_EQ(14, FindMapping({"mpa", 90000, 0}));
EXPECT_EQ(14, FindMapping({"mpa", 90000, 1}));
EXPECT_EQ(15, FindMapping({"g728", 8000, 1}));
EXPECT_EQ(16, FindMapping({"dvi4", 11025, 1}));
EXPECT_EQ(17, FindMapping({"dvi4", 22050, 1}));
EXPECT_EQ(18, FindMapping({"g729", 8000, 1}));
EXPECT_EQ(0, mapper_.FindMappingFor({"pcmu", 8000, 1}));
EXPECT_EQ(3, mapper_.FindMappingFor({"gsm", 8000, 1}));
EXPECT_EQ(4, mapper_.FindMappingFor({"g723", 8000, 1}));
EXPECT_EQ(5, mapper_.FindMappingFor({"dvi4", 8000, 1}));
EXPECT_EQ(6, mapper_.FindMappingFor({"dvi4", 16000, 1}));
EXPECT_EQ(7, mapper_.FindMappingFor({"lpc", 8000, 1}));
EXPECT_EQ(8, mapper_.FindMappingFor({"pcma", 8000, 1}));
EXPECT_EQ(9, mapper_.FindMappingFor({"g722", 8000, 1}));
EXPECT_EQ(10, mapper_.FindMappingFor({"l16", 44100, 2}));
EXPECT_EQ(11, mapper_.FindMappingFor({"l16", 44100, 1}));
EXPECT_EQ(12, mapper_.FindMappingFor({"qcelp", 8000, 1}));
EXPECT_EQ(13, mapper_.FindMappingFor({"cn", 8000, 1}));
EXPECT_EQ(14, mapper_.FindMappingFor({"mpa", 90000, 0}));
EXPECT_EQ(14, mapper_.FindMappingFor({"mpa", 90000, 1}));
EXPECT_EQ(15, mapper_.FindMappingFor({"g728", 8000, 1}));
EXPECT_EQ(16, mapper_.FindMappingFor({"dvi4", 11025, 1}));
EXPECT_EQ(17, mapper_.FindMappingFor({"dvi4", 22050, 1}));
EXPECT_EQ(18, mapper_.FindMappingFor({"g729", 8000, 1}));
}
TEST_F(PayloadTypeMapperTest, WebRTCPayloadTypes) {
// Tests that the payload mapper knows about the audio and data formats we've
// been using in WebRTC, with their hard coded values.
auto data_mapping = [this] (const char *name) {
return FindMapping({name, 0, 0});
return mapper_.FindMappingFor({name, 0, 0});
};
EXPECT_EQ(kGoogleRtpDataCodecPlType, data_mapping(kGoogleRtpDataCodecName));
EXPECT_EQ(kGoogleSctpDataCodecPlType, data_mapping(kGoogleSctpDataCodecName));
EXPECT_EQ(102, FindMapping({kIlbcCodecName, 8000, 1}));
EXPECT_EQ(103, FindMapping({kIsacCodecName, 16000, 1}));
EXPECT_EQ(104, FindMapping({kIsacCodecName, 32000, 1}));
EXPECT_EQ(105, FindMapping({kCnCodecName, 16000, 1}));
EXPECT_EQ(106, FindMapping({kCnCodecName, 32000, 1}));
EXPECT_EQ(111, FindMapping({kOpusCodecName, 48000, 2,
EXPECT_EQ(102, mapper_.FindMappingFor({kIlbcCodecName, 8000, 1}));
EXPECT_EQ(103, mapper_.FindMappingFor({kIsacCodecName, 16000, 1}));
EXPECT_EQ(104, mapper_.FindMappingFor({kIsacCodecName, 32000, 1}));
EXPECT_EQ(105, mapper_.FindMappingFor({kCnCodecName, 16000, 1}));
EXPECT_EQ(106, mapper_.FindMappingFor({kCnCodecName, 32000, 1}));
EXPECT_EQ(111, mapper_.FindMappingFor({kOpusCodecName, 48000, 2,
{{"minptime", "10"}, {"useinbandfec", "1"}}}));
// TODO(solenberg): Remove 16k, 32k, 48k DTMF checks once these payload types
// are dynamically assigned.
EXPECT_EQ(110, FindMapping({kDtmfCodecName, 48000, 1}));
EXPECT_EQ(112, FindMapping({kDtmfCodecName, 32000, 1}));
EXPECT_EQ(113, FindMapping({kDtmfCodecName, 16000, 1}));
EXPECT_EQ(126, FindMapping({kDtmfCodecName, 8000, 1}));
EXPECT_EQ(110, mapper_.FindMappingFor({kDtmfCodecName, 48000, 1}));
EXPECT_EQ(112, mapper_.FindMappingFor({kDtmfCodecName, 32000, 1}));
EXPECT_EQ(113, mapper_.FindMappingFor({kDtmfCodecName, 16000, 1}));
EXPECT_EQ(126, mapper_.FindMappingFor({kDtmfCodecName, 8000, 1}));
}
TEST_F(PayloadTypeMapperTest, ValidDynamicPayloadTypes) {
@ -118,10 +101,10 @@ TEST_F(PayloadTypeMapperTest, ValidDynamicPayloadTypes) {
if (payload_type < 96)
has_been_below_96 = true;
EXPECT_EQ(payload_type, FindMapping(format))
EXPECT_EQ(payload_type, mapper_.FindMappingFor(format))
<< "Mapping must be permanent after successful call to "
"GetMappingFor";
EXPECT_EQ(payload_type, GetMapping(format))
EXPECT_EQ(payload_type, mapper_.GetMappingFor(format))
<< "Subsequent calls to GetMappingFor must return the same value";
} else {
mapper_is_full = true;

48
media/engine/webrtcvideoengine.cc
View File

@ -380,25 +380,25 @@ const char kForcedFallbackFieldTrial[] =
rtc::Optional<int> GetFallbackMinBpsFromFieldTrial() {
if (!webrtc::field_trial::IsEnabled(kForcedFallbackFieldTrial))
return rtc::Optional<int>();
return rtc::nullopt;
std::string group =
webrtc::field_trial::FindFullName(kForcedFallbackFieldTrial);
if (group.empty())
return rtc::Optional<int>();
return rtc::nullopt;
int min_pixels;
int max_pixels;
int min_bps;
if (sscanf(group.c_str(), "Enabled-%d,%d,%d", &min_pixels, &max_pixels,
&min_bps) != 3) {
return rtc::Optional<int>();
return rtc::nullopt;
}
if (min_bps <= 0)
return rtc::Optional<int>();
return rtc::nullopt;
return rtc::Optional<int>(min_bps);
return min_bps;
}
int GetMinVideoBitrateBps() {
@ -626,10 +626,10 @@ WebRtcVideoChannel::SelectSendVideoCodec(
// since we should limit the encode level to the lower of local and remote
// level when level asymmetry is not allowed.
if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec))
return rtc::Optional<VideoCodecSettings>(remote_mapped_codec);
return remote_mapped_codec;
}
// No remote codec was supported.
return rtc::Optional<VideoCodecSettings>();
return rtc::nullopt;
}
bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged(
@ -705,21 +705,20 @@ bool WebRtcVideoChannel::GetChangedSendParameters(
// 0 or -1 uncaps max bitrate.
// TODO(pbos): Reconsider how 0 should be treated. It is not mentioned as a
// special value and might very well be used for stopping sending.
changed_params->max_bandwidth_bps = rtc::Optional<int>(
params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps);
changed_params->max_bandwidth_bps =
params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps;
}
// Handle conference mode.
if (params.conference_mode != send_params_.conference_mode) {
changed_params->conference_mode =
rtc::Optional<bool>(params.conference_mode);
changed_params->conference_mode = params.conference_mode;
}
// Handle RTCP mode.
if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) {
changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>(
params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize
: webrtc::RtcpMode::kCompound);
changed_params->rtcp_mode = params.rtcp.reduced_size
? webrtc::RtcpMode::kReducedSize
: webrtc::RtcpMode::kCompound;
}
return true;
@ -739,7 +738,7 @@ bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) {
if (changed_params.codec) {
const VideoCodecSettings& codec_settings = *changed_params.codec;
send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings);
send_codec_ = codec_settings;
RTC_LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString();
}
@ -959,8 +958,7 @@ bool WebRtcVideoChannel::GetChangedRecvParameters(
int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type;
if (flexfec_payload_type != recv_flexfec_payload_type_) {
changed_params->flexfec_payload_type =
rtc::Optional<int>(flexfec_payload_type);
changed_params->flexfec_payload_type = flexfec_payload_type;
}
return true;
@ -1577,8 +1575,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
// ValidateStreamParams should prevent this from happening.
RTC_CHECK(!parameters_.config.rtp.ssrcs.empty());
rtp_parameters_.encodings[0].ssrc =
rtc::Optional<uint32_t>(parameters_.config.rtp.ssrcs[0]);
rtp_parameters_.encodings[0].ssrc = parameters_.config.rtp.ssrcs[0];
// RTX.
sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
@ -1748,8 +1745,7 @@ void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec(
parameters_.config.rtp.nack.rtp_history_ms =
HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
parameters_.codec_settings =
rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>(codec_settings);
parameters_.codec_settings = codec_settings;
RTC_LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec.";
RecreateWebRtcStream();
@ -1975,8 +1971,7 @@ VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo(
if (parameters_.codec_settings) {
info.codec_name = parameters_.codec_settings->codec.name;
info.codec_payload_type = rtc::Optional<int>(
parameters_.codec_settings->codec.id);
info.codec_payload_type = parameters_.codec_settings->codec.id;
}
if (stream_ == NULL)
@ -2146,9 +2141,9 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const {
if (primary_ssrcs.empty()) {
RTC_LOG(LS_WARNING)
<< "Empty primary ssrcs vector, returning empty optional";
return rtc::Optional<uint32_t>();
return rtc::nullopt;
} else {
return rtc::Optional<uint32_t>(primary_ssrcs[0]);
return primary_ssrcs[0];
}
}
@ -2395,8 +2390,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
info.decoder_implementation_name = stats.decoder_implementation_name;
if (stats.current_payload_type != -1) {
info.codec_payload_type = rtc::Optional<int>(
stats.current_payload_type);
info.codec_payload_type = stats.current_payload_type;
}
info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
stats.rtp_stats.transmitted.header_bytes +

44
media/engine/webrtcvideoengine_unittest.cc
View File

@ -1374,7 +1374,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
cricket::FakeVideoCapturer* capturer,
bool enabled) {
cricket::VideoOptions options;
options.video_noise_reduction = rtc::Optional<bool>(enabled);
options.video_noise_reduction = enabled;
EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer));
// Options only take effect on the next frame.
EXPECT_TRUE(capturer->CaptureFrame());
@ -1420,13 +1420,12 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
webrtc::RtpParameters parameters =
channel_->GetRtpSendParameters(last_ssrc_);
EXPECT_EQ(1UL, parameters.encodings.size());
parameters.encodings[0].max_bitrate_bps = rtc::Optional<int>(stream_max);
parameters.encodings[0].max_bitrate_bps = stream_max;
EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
// Read back the parameteres and verify they have the correct value
parameters = channel_->GetRtpSendParameters(last_ssrc_);
EXPECT_EQ(1UL, parameters.encodings.size());
EXPECT_EQ(rtc::Optional<int>(stream_max),
parameters.encodings[0].max_bitrate_bps);
EXPECT_EQ(stream_max, parameters.encodings[0].max_bitrate_bps);
// Verify that the new value propagated down to the encoder
EXPECT_EQ(expected_encoder_bitrate, GetMaxEncoderBitrate());
}
@ -1876,8 +1875,7 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
cricket::FakeVideoCapturer capturer;
VideoOptions min_bitrate_options;
min_bitrate_options.screencast_min_bitrate_kbps =
rtc::Optional<int>(kScreenshareMinBitrateKbps);
min_bitrate_options.screencast_min_bitrate_kbps = kScreenshareMinBitrateKbps;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options,
&capturer));
cricket::VideoFormat capture_format_hd =
@ -1908,7 +1906,7 @@ TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
EXPECT_EQ(1, send_stream->GetNumberOfSwappedFrames());
VideoOptions screencast_options;
screencast_options.is_screencast = rtc::Optional<bool>(true);
screencast_options.is_screencast = true;
EXPECT_TRUE(
channel_->SetVideoSend(last_ssrc_, true, &screencast_options, &capturer));
EXPECT_TRUE(capturer.CaptureFrame());
@ -1940,7 +1938,7 @@ TEST_F(WebRtcVideoChannelTest,
AddSendStream();
VideoOptions options;
options.is_screencast = rtc::Optional<bool>(true);
options.is_screencast = true;
cricket::FakeVideoCapturer capturer;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
cricket::VideoFormat capture_format_hd =
@ -2057,7 +2055,7 @@ TEST_F(WebRtcVideoChannelTest, VerifyVp8SpecificSettings) {
// In screen-share mode, denoising is forced off and simulcast disabled.
VideoOptions options;
options.is_screencast = rtc::Optional<bool>(true);
options.is_screencast = true;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
stream = SetDenoisingOption(last_ssrc_, &capturer, false);
@ -2104,7 +2102,7 @@ TEST_F(WebRtcVideoChannelTest, SetIdenticalOptionsDoesntReconfigureEncoder) {
EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
// Change |options| and expect 2 reconfigurations.
options.video_noise_reduction = rtc::Optional<bool>(true);
options.video_noise_reduction = true;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
EXPECT_EQ(2, send_stream->num_encoder_reconfigurations());
@ -2163,7 +2161,7 @@ TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
// In screen-share mode, denoising is forced off.
VideoOptions options;
options.is_screencast = rtc::Optional<bool>(true);
options.is_screencast = true;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
stream = SetDenoisingOption(last_ssrc_, &capturer, false);
@ -2351,7 +2349,7 @@ TEST_F(WebRtcVideoChannelTest, AdaptsOnOveruseAndChangeResolution) {
// of the current stream, so we don't take too large steps.
wants.max_pixel_count = current_pixel_count * 4;
// Default step down is 3/5 pixel count, so go up by 5/3.
wants.target_pixel_count = rtc::Optional<int>((current_pixel_count * 5) / 3);
wants.target_pixel_count = (current_pixel_count * 5 / 3);
send_stream->InjectVideoSinkWants(wants);
EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
EXPECT_EQ(5, send_stream->GetNumberOfSwappedFrames());
@ -2362,7 +2360,7 @@ TEST_F(WebRtcVideoChannelTest, AdaptsOnOveruseAndChangeResolution) {
current_pixel_count =
send_stream->GetLastWidth() * send_stream->GetLastHeight();
wants.max_pixel_count = current_pixel_count * 4;
wants.target_pixel_count = rtc::Optional<int>((current_pixel_count * 5) / 3);
wants.target_pixel_count = (current_pixel_count * 5 / 3);
send_stream->InjectVideoSinkWants(wants);
EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
@ -2391,7 +2389,7 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
capturer.Start(capturer.GetSupportedFormats()->front()));
ASSERT_TRUE(channel_->SetSend(true));
cricket::VideoOptions camera_options;
camera_options.is_screencast = rtc::Optional<bool>(false);
camera_options.is_screencast = false;
channel_->SetVideoSend(last_ssrc_, true /* enable */, &camera_options,
&capturer);
@ -2418,7 +2416,7 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
ASSERT_EQ(cricket::CS_RUNNING,
screen_share.Start(screen_share.GetSupportedFormats()->front()));
cricket::VideoOptions screenshare_options;
screenshare_options.is_screencast = rtc::Optional<bool>(true);
screenshare_options.is_screencast = true;
channel_->SetVideoSend(last_ssrc_, true /* enable */, &screenshare_options,
&screen_share);
EXPECT_TRUE(screen_share.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
@ -2501,7 +2499,7 @@ void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
cricket::FakeVideoCapturer capturer;
VideoOptions options;
options.is_screencast = rtc::Optional<bool>(is_screenshare);
options.is_screencast = is_screenshare;
EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
cricket::VideoFormat capture_format = capturer.GetSupportedFormats()->front();
capture_format.interval = rtc::kNumNanosecsPerSec / kDefaultFps;
@ -3708,7 +3706,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsFramesEncoded) {
TEST_F(WebRtcVideoChannelTest, GetStatsReportsQpSum) {
FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.qp_sum = rtc::Optional<uint64_t>(13);
stats.qp_sum = 13;
stream->SetStats(stats);
cricket::VideoMediaInfo info;
@ -3848,7 +3846,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
stats.frame_counts.delta_frames = 12;
stats.frames_rendered = 13;
stats.frames_decoded = 14;
stats.qp_sum = rtc::Optional<uint64_t>(15);
stats.qp_sum = 15;
stream->SetStats(stats);
cricket::VideoMediaInfo info;
@ -4357,7 +4355,7 @@ TEST_F(WebRtcVideoChannelTest,
TEST_F(WebRtcVideoChannelTest, CannotSetSsrcInRtpSendParameters) {
AddSendStream();
webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
parameters.encodings[0].ssrc = rtc::Optional<uint32_t>(0xdeadbeef);
parameters.encodings[0].ssrc = 0xdeadbeef;
EXPECT_FALSE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
}
@ -4449,8 +4447,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpSendParametersSsrc) {
webrtc::RtpParameters rtp_parameters =
channel_->GetRtpSendParameters(last_ssrc_);
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_),
rtp_parameters.encodings[0].ssrc);
EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc);
}
// Test that if we set/get parameters multiple times, we get the same results.
@ -4532,8 +4529,7 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveParametersSsrc) {
webrtc::RtpParameters rtp_parameters =
channel_->GetRtpReceiveParameters(last_ssrc_);
ASSERT_EQ(1u, rtp_parameters.encodings.size());
EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_),
rtp_parameters.encodings[0].ssrc);
EXPECT_EQ(last_ssrc_, rtp_parameters.encodings[0].ssrc);
}
// Test that if we set/get parameters multiple times, we get the same results.
@ -4692,7 +4688,7 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
cricket::FakeVideoCapturer capturer;
VideoOptions options;
if (screenshare)
options.is_screencast = rtc::Optional<bool>(screenshare);
options.is_screencast = screenshare;
EXPECT_TRUE(
channel_->SetVideoSend(ssrcs.front(), true, &options, &capturer));
// Fetch the latest stream since SetVideoSend() may recreate it if the

104
media/engine/webrtcvoiceengine.cc
View File

@ -155,7 +155,7 @@ rtc::Optional<std::string> GetAudioNetworkAdaptorConfig(
// equals true and |options_.audio_network_adaptor_config| has a value.
return options.audio_network_adaptor_config;
}
return rtc::Optional<std::string>();
return rtc::nullopt;
}
webrtc::AudioState::Config MakeAudioStateConfig(
@ -185,7 +185,7 @@ rtc::Optional<int> ComputeSendBitrate(int max_send_bitrate_bps,
? webrtc::MinPositive(max_send_bitrate_bps, *rtp_max_bitrate_bps)
: max_send_bitrate_bps;
if (bps <= 0) {
return rtc::Optional<int>(spec.info.default_bitrate_bps);
return spec.info.default_bitrate_bps;
}
if (bps < spec.info.min_bitrate_bps) {
@ -196,14 +196,14 @@ rtc::Optional<int> ComputeSendBitrate(int max_send_bitrate_bps,
<< " to bitrate " << bps << " bps"
<< ", requires at least " << spec.info.min_bitrate_bps
<< " bps.";
return rtc::Optional<int>();
return rtc::nullopt;
}
if (spec.info.HasFixedBitrate()) {
return rtc::Optional<int>(spec.info.default_bitrate_bps);
return spec.info.default_bitrate_bps;
} else {
// If codec is multi-rate then just set the bitrate.
return rtc::Optional<int>(std::min(bps, spec.info.max_bitrate_bps));
return std::min(bps, spec.info.max_bitrate_bps);
}
}
@ -302,22 +302,22 @@ void WebRtcVoiceEngine::Init() {
// Set default engine options.
{
AudioOptions options;
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.intelligibility_enhancer = rtc::Optional<bool>(false);
options.level_control = rtc::Optional<bool>(false);
options.residual_echo_detector = rtc::Optional<bool>(true);
options.echo_cancellation = true;
options.auto_gain_control = true;
options.noise_suppression = true;
options.highpass_filter = true;
options.stereo_swapping = false;
options.audio_jitter_buffer_max_packets = 50;
options.audio_jitter_buffer_fast_accelerate = false;
options.typing_detection = true;
options.adjust_agc_delta = 0;
options.experimental_agc = false;
options.extended_filter_aec = false;
options.delay_agnostic_aec = false;
options.experimental_ns = false;
options.intelligibility_enhancer = false;
options.level_control = false;
options.residual_echo_detector = true;
bool error = ApplyOptions(options);
RTC_DCHECK(error);
}
@ -369,12 +369,12 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
#if defined(WEBRTC_IOS)
// On iOS, VPIO provides built-in EC.
options.echo_cancellation = rtc::Optional<bool>(false);
options.extended_filter_aec = rtc::Optional<bool>(false);
options.echo_cancellation = false;
options.extended_filter_aec = false;
RTC_LOG(LS_INFO) << "Always disable AEC on iOS. Use built-in instead.";
#elif defined(WEBRTC_ANDROID)
ec_mode = webrtc::kEcAecm;
options.extended_filter_aec = rtc::Optional<bool>(false);
options.extended_filter_aec = false;
#endif
// Delay Agnostic AEC automatically turns on EC if not set except on iOS
@ -384,8 +384,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::Optional<bool>(true);
options.extended_filter_aec = rtc::Optional<bool>(true);
options.echo_cancellation = true;
options.extended_filter_aec = true;
ec_mode = webrtc::kEcConference;
}
}
@ -394,23 +394,23 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
// Set and adjust noise suppressor options.
#if defined(WEBRTC_IOS)
// On iOS, VPIO provides built-in NS.
options.noise_suppression = rtc::Optional<bool>(false);
options.typing_detection = rtc::Optional<bool>(false);
options.experimental_ns = rtc::Optional<bool>(false);
options.noise_suppression = false;
options.typing_detection = false;
options.experimental_ns = false;
RTC_LOG(LS_INFO) << "Always disable NS on iOS. Use built-in instead.";
#elif defined(WEBRTC_ANDROID)
options.typing_detection = rtc::Optional<bool>(false);
options.experimental_ns = rtc::Optional<bool>(false);
options.typing_detection = false;
options.experimental_ns = false;
#endif
// Set and adjust gain control options.
#if defined(WEBRTC_IOS)
// On iOS, VPIO provides built-in AGC.
options.auto_gain_control = rtc::Optional<bool>(false);
options.experimental_agc = rtc::Optional<bool>(false);
options.auto_gain_control = false;
options.experimental_agc = false;
RTC_LOG(LS_INFO) << "Always disable AGC on iOS. Use built-in instead.";
#elif defined(WEBRTC_ANDROID)
options.experimental_agc = rtc::Optional<bool>(false);
options.experimental_agc = false;
#endif
#if defined(WEBRTC_IOS) || defined(WEBRTC_ANDROID)
@ -421,21 +421,21 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
// (https://bugs.chromium.org/p/webrtc/issues/detail?id=6181).
if (webrtc::field_trial::IsEnabled(
"WebRTC-Audio-MinimizeResamplingOnMobile")) {
options.auto_gain_control = rtc::Optional<bool>(false);
options.auto_gain_control = false;
RTC_LOG(LS_INFO) << "Disable AGC according to field trial.";
if (!(options.noise_suppression.value_or(false) ||
options.echo_cancellation.value_or(false))) {
// If possible, turn off the high-pass filter.
RTC_LOG(LS_INFO)
<< "Disable high-pass filter in response to field trial.";
options.highpass_filter = rtc::Optional<bool>(false);
options.highpass_filter = false;
}
}
#endif
#if (WEBRTC_INTELLIGIBILITY_ENHANCER == 0)
// Hardcode the intelligibility enhancer to be off.
options.intelligibility_enhancer = rtc::Optional<bool>(false);
options.intelligibility_enhancer = false;
#endif
if (options.echo_cancellation) {
@ -454,7 +454,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::Optional<bool>(false);
options.echo_cancellation = false;
RTC_LOG(LS_INFO)
<< "Disabling EC since built-in EC will be used instead";
}
@ -477,7 +477,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::Optional<bool>(false);
options.auto_gain_control = false;
RTC_LOG(LS_INFO)
<< "Disabling AGC since built-in AGC will be used instead";
}
@ -529,7 +529,7 @@ bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
if (adm()->EnableBuiltInNS(builtin_ns) == 0 && builtin_ns) {
// 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::Optional<bool>(false);
options.noise_suppression = false;
RTC_LOG(LS_INFO)
<< "Disabling NS since built-in NS will be used instead";
}
@ -834,7 +834,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
config_.audio_network_adaptor_config = audio_network_adaptor_config;
config_.encoder_factory = encoder_factory;
config_.track_id = track_id;
rtp_parameters_.encodings[0].ssrc = rtc::Optional<uint32_t>(ssrc);
rtp_parameters_.encodings[0].ssrc = ssrc;
if (send_codec_spec) {
UpdateSendCodecSpec(*send_codec_spec);
@ -1096,9 +1096,7 @@ class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
config_.rtp.nack.rtp_history_ms =
send_codec_spec.nack_enabled ? kNackRtpHistoryMs : 0;
config_.send_codec_spec =
rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>(
send_codec_spec);
config_.send_codec_spec = send_codec_spec;
auto info =
config_.encoder_factory->QueryAudioEncoder(send_codec_spec.format);
RTC_DCHECK(info);
@ -1455,7 +1453,7 @@ webrtc::RtpParameters WebRtcVoiceMediaChannel::GetRtpReceiveParameters(
}
rtp_params.encodings.emplace_back();
// TODO(deadbeef): Return stream-specific parameters.
rtp_params.encodings[0].ssrc = rtc::Optional<uint32_t>(ssrc);
rtp_params.encodings[0].ssrc = ssrc;
}
for (const AudioCodec& codec : recv_codecs_) {
@ -1603,7 +1601,7 @@ bool WebRtcVoiceMediaChannel::SetRecvCodecs(
bool WebRtcVoiceMediaChannel::SetSendCodecs(
const std::vector<AudioCodec>& codecs) {
RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
dtmf_payload_type_ = rtc::Optional<int>();
dtmf_payload_type_ = rtc::nullopt;
dtmf_payload_freq_ = -1;
// Validate supplied codecs list.
@ -1626,7 +1624,7 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
if (IsCodec(codec, kDtmfCodecName)) {
dtmf_codecs.push_back(codec);
if (!dtmf_payload_type_ || codec.clockrate < dtmf_payload_freq_) {
dtmf_payload_type_ = rtc::Optional<int>(codec.id);
dtmf_payload_type_ = codec.id;
dtmf_payload_freq_ = codec.clockrate;
}
}
@ -1649,12 +1647,10 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
continue;
}
send_codec_spec =
rtc::Optional<webrtc::AudioSendStream::Config::SendCodecSpec>(
{voice_codec.id, format});
send_codec_spec = webrtc::AudioSendStream::Config::SendCodecSpec(
voice_codec.id, format);
if (voice_codec.bitrate > 0) {
send_codec_spec->target_bitrate_bps =
rtc::Optional<int>(voice_codec.bitrate);
send_codec_spec->target_bitrate_bps = voice_codec.bitrate;
}
send_codec_spec->transport_cc_enabled = HasTransportCc(voice_codec);
send_codec_spec->nack_enabled = HasNack(voice_codec);
@ -1678,7 +1674,7 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
case 8000:
case 16000:
case 32000:
send_codec_spec->cng_payload_type = rtc::Optional<int>(cn_codec.id);
send_codec_spec->cng_payload_type = cn_codec.id;
break;
default:
RTC_LOG(LS_WARNING)
@ -1692,7 +1688,7 @@ bool WebRtcVoiceMediaChannel::SetSendCodecs(
// Find the telephone-event PT exactly matching the preferred send codec.
for (const AudioCodec& dtmf_codec : dtmf_codecs) {
if (dtmf_codec.clockrate == send_codec_spec->format.clockrate_hz) {
dtmf_payload_type_ = rtc::Optional<int>(dtmf_codec.id);
dtmf_payload_type_ = dtmf_codec.id;
dtmf_payload_freq_ = dtmf_codec.clockrate;
break;
}

142
media/engine/webrtcvoiceengine_unittest.cc
View File

@ -370,7 +370,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(ssrc);
EXPECT_EQ(1UL, parameters.encodings.size());
parameters.encodings[0].max_bitrate_bps = rtc::Optional<int>(bitrate);
parameters.encodings[0].max_bitrate_bps = bitrate;
return channel_->SetRtpSendParameters(ssrc, parameters);
}
@ -534,7 +534,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
stats.packets_lost = 9012;
stats.fraction_lost = 34.56f;
stats.codec_name = "codec_name_send";
stats.codec_payload_type = rtc::Optional<int>(42);
stats.codec_payload_type = 42;
stats.ext_seqnum = 789;
stats.jitter_ms = 12;
stats.rtt_ms = 345;
@ -546,16 +546,13 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
stats.echo_return_loss_enhancement = 1234;
stats.residual_echo_likelihood = 0.432f;
stats.residual_echo_likelihood_recent_max = 0.6f;
stats.ana_statistics.bitrate_action_counter = rtc::Optional<uint32_t>(321);
stats.ana_statistics.channel_action_counter = rtc::Optional<uint32_t>(432);
stats.ana_statistics.dtx_action_counter = rtc::Optional<uint32_t>(543);
stats.ana_statistics.fec_action_counter = rtc::Optional<uint32_t>(654);
stats.ana_statistics.frame_length_increase_counter =
rtc::Optional<uint32_t>(765);
stats.ana_statistics.frame_length_decrease_counter =
rtc::Optional<uint32_t>(876);
stats.ana_statistics.uplink_packet_loss_fraction =
rtc::Optional<float>(987.0);
stats.ana_statistics.bitrate_action_counter = 321;
stats.ana_statistics.channel_action_counter = 432;
stats.ana_statistics.dtx_action_counter = 543;
stats.ana_statistics.fec_action_counter = 654;
stats.ana_statistics.frame_length_increase_counter = 765;
stats.ana_statistics.frame_length_decrease_counter = 876;
stats.ana_statistics.uplink_packet_loss_fraction = 987.0;
stats.typing_noise_detected = true;
return stats;
}
@ -613,7 +610,7 @@ class WebRtcVoiceEngineTestFake : public testing::Test {
stats.packets_lost = 101;
stats.fraction_lost = 23.45f;
stats.codec_name = "codec_name_recv";
stats.codec_payload_type = rtc::Optional<int>(42);
stats.codec_payload_type = 42;
stats.ext_seqnum = 678;
stats.jitter_ms = 901;
stats.jitter_buffer_ms = 234;
@ -1070,7 +1067,7 @@ TEST_F(WebRtcVoiceEngineTestFake,
TEST_F(WebRtcVoiceEngineTestFake, CannotSetSsrcInRtpSendParameters) {
EXPECT_TRUE(SetupSendStream());
webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(kSsrcX);
parameters.encodings[0].ssrc = rtc::Optional<uint32_t>(0xdeadbeef);
parameters.encodings[0].ssrc = 0xdeadbeef;
EXPECT_FALSE(channel_->SetRtpSendParameters(kSsrcX, parameters));
}
@ -1178,8 +1175,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetRtpSendParameterUpdatesMaxBitrate) {
EXPECT_FALSE(rtp_parameters.encodings[0].max_bitrate_bps);
constexpr int kMaxBitrateBps = 6000;
rtp_parameters.encodings[0].max_bitrate_bps =
rtc::Optional<int>(kMaxBitrateBps);
rtp_parameters.encodings[0].max_bitrate_bps = kMaxBitrateBps;
EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, rtp_parameters));
const int max_bitrate = GetSendStreamConfig(kSsrcX).max_bitrate_bps;
@ -1282,7 +1278,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecs) {
EXPECT_EQ(22000, send_codec_spec.target_bitrate_bps);
EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
EXPECT_NE(send_codec_spec.format.clockrate_hz, 8000);
EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type);
EXPECT_EQ(rtc::nullopt, send_codec_spec.cng_payload_type);
EXPECT_FALSE(channel_->CanInsertDtmf());
}
@ -1859,7 +1855,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
{
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type);
EXPECT_EQ(rtc::nullopt, send_codec_spec.cng_payload_type);
}
// Set PCMU(8K) and CN(8K). VAD should be activated.
parameters.codecs[1] = kCn8000Codec;
@ -1876,7 +1872,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsCNNoMatch) {
{
const auto& send_codec_spec = *GetSendStreamConfig(kSsrcX).send_codec_spec;
EXPECT_STRCASEEQ("ISAC", send_codec_spec.format.name.c_str());
EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type);
EXPECT_EQ(rtc::nullopt, send_codec_spec.cng_payload_type);
}
}
@ -2070,7 +2066,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetSendCodecsWithMultipleSendStreams) {
const auto& send_codec_spec =
*call_.GetAudioSendStream(ssrc)->GetConfig().send_codec_spec;
EXPECT_STRCASEEQ("PCMU", send_codec_spec.format.name.c_str());
EXPECT_EQ(rtc::Optional<int>(), send_codec_spec.cng_payload_type);
EXPECT_EQ(rtc::nullopt, send_codec_spec.cng_payload_type);
}
}
@ -2205,7 +2201,7 @@ TEST_F(WebRtcVoiceEngineTestFake, PlayoutWithMultipleStreams) {
// and start sending on it.
TEST_F(WebRtcVoiceEngineTestFake, CodianSend) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10);
send_parameters_.options.adjust_agc_delta = -10;
EXPECT_CALL(apm_gc_,
set_target_level_dbfs(11)).Times(2).WillRepeatedly(Return(0));
SetSendParameters(send_parameters_);
@ -2221,11 +2217,10 @@ TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
BuiltInAGCIsAvailable()).Times(2).WillRepeatedly(Return(false));
EXPECT_CALL(adm_, SetAGC(true)).Times(2).WillRepeatedly(Return(0));
EXPECT_CALL(apm_gc_, Enable(true)).Times(2).WillOnce(Return(0));
send_parameters_.options.tx_agc_target_dbov = rtc::Optional<uint16_t>(3);
send_parameters_.options.tx_agc_digital_compression_gain =
rtc::Optional<uint16_t>(9);
send_parameters_.options.tx_agc_limiter = rtc::Optional<bool>(true);
send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
send_parameters_.options.tx_agc_target_dbov = 3;
send_parameters_.options.tx_agc_digital_compression_gain = 9;
send_parameters_.options.tx_agc_limiter = true;
send_parameters_.options.auto_gain_control = true;
EXPECT_CALL(apm_gc_, set_target_level_dbfs(3)).WillOnce(Return(0));
EXPECT_CALL(apm_gc_, set_compression_gain_db(9)).WillRepeatedly(Return(0));
EXPECT_CALL(apm_gc_, enable_limiter(true)).WillRepeatedly(Return(0));
@ -2233,16 +2228,15 @@ TEST_F(WebRtcVoiceEngineTestFake, TxAgcConfigViaOptions) {
// Check interaction with adjust_agc_delta. Both should be respected, for
// backwards compatibility.
send_parameters_.options.adjust_agc_delta = rtc::Optional<int>(-10);
send_parameters_.options.adjust_agc_delta = -10;
EXPECT_CALL(apm_gc_, set_target_level_dbfs(13)).WillOnce(Return(0));
SetSendParameters(send_parameters_);
}
TEST_F(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true);
send_parameters_.options.audio_network_adaptor_config =
rtc::Optional<std::string>("1234");
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSendParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
@ -2250,29 +2244,27 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioNetworkAdaptorViaOptions) {
TEST_F(WebRtcVoiceEngineTestFake, AudioSendResetAudioNetworkAdaptor) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true);
send_parameters_.options.audio_network_adaptor_config =
rtc::Optional<std::string>("1234");
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSendParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
cricket::AudioOptions options;
options.audio_network_adaptor = rtc::Optional<bool>(false);
options.audio_network_adaptor = false;
SetAudioSend(kSsrcX, true, nullptr, &options);
EXPECT_EQ(rtc::Optional<std::string>(), GetAudioNetworkAdaptorConfig(kSsrcX));
EXPECT_EQ(rtc::nullopt, GetAudioNetworkAdaptorConfig(kSsrcX));
}
TEST_F(WebRtcVoiceEngineTestFake, AudioNetworkAdaptorNotGetOverridden) {
EXPECT_TRUE(SetupSendStream());
send_parameters_.options.audio_network_adaptor = rtc::Optional<bool>(true);
send_parameters_.options.audio_network_adaptor_config =
rtc::Optional<std::string>("1234");
send_parameters_.options.audio_network_adaptor = true;
send_parameters_.options.audio_network_adaptor_config = {"1234"};
SetSendParameters(send_parameters_);
EXPECT_EQ(send_parameters_.options.audio_network_adaptor_config,
GetAudioNetworkAdaptorConfig(kSsrcX));
const int initial_num = call_.GetNumCreatedSendStreams();
cricket::AudioOptions options;
options.audio_network_adaptor = rtc::Optional<bool>();
options.audio_network_adaptor = rtc::nullopt;
// Unvalued |options.audio_network_adaptor|.should not reset audio network
// adaptor.
SetAudioSend(kSsrcX, true, nullptr, &options);
@ -2312,9 +2304,8 @@ TEST_F(WebRtcVoiceEngineWithSendSideBweWithOverheadTest, MinAndMaxBitrate) {
EXPECT_EQ(kOpusBitrateFbBps + kMinOverheadBps,
GetSendStreamConfig(kSsrcX).max_bitrate_bps);
parameters.options.audio_network_adaptor = rtc::Optional<bool>(true);
parameters.options.audio_network_adaptor_config =
rtc::Optional<std::string>("1234");
parameters.options.audio_network_adaptor = true;
parameters.options.audio_network_adaptor_config = {"1234"};
SetSendParameters(parameters);
constexpr int kMinOverheadWithAnaBps =
@ -2342,8 +2333,7 @@ TEST_F(WebRtcVoiceEngineWithSendSideBweWithOverheadTest,
EXPECT_FALSE(rtp_parameters.encodings[0].max_bitrate_bps);
constexpr int kMaxBitrateBps = 6000;
rtp_parameters.encodings[0].max_bitrate_bps =
rtc::Optional<int>(kMaxBitrateBps);
rtp_parameters.encodings[0].max_bitrate_bps = kMaxBitrateBps;
EXPECT_TRUE(channel_->SetRtpSendParameters(kSsrcX, rtp_parameters));
const int max_bitrate = GetSendStreamConfig(kSsrcX).max_bitrate_bps;
@ -2745,35 +2735,35 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
// Turn echo cancellation off
EXPECT_CALL(apm_ec_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(false)).WillOnce(Return(0));
send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
send_parameters_.options.echo_cancellation = false;
SetSendParameters(send_parameters_);
// Turn echo cancellation back on, with settings, and make sure
// nothing else changed.
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
send_parameters_.options.echo_cancellation = rtc::Optional<bool>(true);
send_parameters_.options.echo_cancellation = true;
SetSendParameters(send_parameters_);
// Turn on delay agnostic aec and make sure nothing change w.r.t. echo
// control.
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
send_parameters_.options.delay_agnostic_aec = true;
SetSendParameters(send_parameters_);
// Turn off echo cancellation and delay agnostic aec.
EXPECT_CALL(apm_ec_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(false)).WillOnce(Return(0));
send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(false);
send_parameters_.options.extended_filter_aec = rtc::Optional<bool>(false);
send_parameters_.options.echo_cancellation = rtc::Optional<bool>(false);
send_parameters_.options.delay_agnostic_aec = false;
send_parameters_.options.extended_filter_aec = false;
send_parameters_.options.echo_cancellation = false;
SetSendParameters(send_parameters_);
// Turning delay agnostic aec back on should also turn on echo cancellation.
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
send_parameters_.options.delay_agnostic_aec = rtc::Optional<bool>(true);
send_parameters_.options.delay_agnostic_aec = true;
SetSendParameters(send_parameters_);
// Turn off AGC
@ -2781,7 +2771,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
EXPECT_CALL(apm_gc_, Enable(false)).WillOnce(Return(0));
send_parameters_.options.auto_gain_control = rtc::Optional<bool>(false);
send_parameters_.options.auto_gain_control = false;
SetSendParameters(send_parameters_);
// Turn AGC back on
@ -2789,8 +2779,8 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
EXPECT_CALL(apm_gc_, Enable(true)).WillOnce(Return(0));
send_parameters_.options.auto_gain_control = rtc::Optional<bool>(true);
send_parameters_.options.adjust_agc_delta = rtc::Optional<int>();
send_parameters_.options.auto_gain_control = true;
send_parameters_.options.adjust_agc_delta = rtc::nullopt;
SetSendParameters(send_parameters_);
// Turn off other options (and stereo swapping on).
@ -2801,10 +2791,10 @@ TEST_F(WebRtcVoiceEngineTestFake, SetAudioOptions) {
EXPECT_CALL(apm_ns_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(apm_vd_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(transmit_mixer_, EnableStereoChannelSwapping(true));
send_parameters_.options.noise_suppression = rtc::Optional<bool>(false);
send_parameters_.options.highpass_filter = rtc::Optional<bool>(false);
send_parameters_.options.typing_detection = rtc::Optional<bool>(false);
send_parameters_.options.stereo_swapping = rtc::Optional<bool>(true);
send_parameters_.options.noise_suppression = false;
send_parameters_.options.highpass_filter = false;
send_parameters_.options.typing_detection = false;
send_parameters_.options.stereo_swapping = true;
SetSendParameters(send_parameters_);
EXPECT_FALSE(IsHighPassFilterEnabled());
@ -2857,9 +2847,9 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
// AEC and AGC and NS
cricket::AudioSendParameters parameters_options_all = send_parameters_;
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);
parameters_options_all.options.echo_cancellation = true;
parameters_options_all.options.auto_gain_control = true;
parameters_options_all.options.noise_suppression = true;
EXPECT_CALL(adm_, SetAGC(true)).Times(2).WillRepeatedly(Return(0));
EXPECT_CALL(apm_ec_, Enable(true)).Times(2).WillRepeatedly(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).Times(2).WillRepeatedly(Return(0));
@ -2872,8 +2862,7 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
// unset NS
cricket::AudioSendParameters parameters_options_no_ns = send_parameters_;
parameters_options_no_ns.options.noise_suppression =
rtc::Optional<bool>(false);
parameters_options_no_ns.options.noise_suppression = false;
EXPECT_CALL(adm_, SetAGC(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
@ -2881,24 +2870,23 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
EXPECT_CALL(apm_ns_, Enable(false)).WillOnce(Return(0));
EXPECT_TRUE(channel1->SetSendParameters(parameters_options_no_ns));
cricket::AudioOptions expected_options = parameters_options_all.options;
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);
expected_options.echo_cancellation = true;
expected_options.auto_gain_control = true;
expected_options.noise_suppression = 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::Optional<bool>(false);
parameters_options_no_agc.options.auto_gain_control = false;
EXPECT_CALL(adm_, SetAGC(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
EXPECT_CALL(apm_gc_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ns_, Enable(true)).WillOnce(Return(0));
EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc));
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);
expected_options.echo_cancellation = true;
expected_options.auto_gain_control = false;
expected_options.noise_suppression = true;
EXPECT_EQ(expected_options, channel2->options());
EXPECT_CALL(adm_, SetAGC(true)).WillOnce(Return(0));
@ -2925,19 +2913,17 @@ TEST_F(WebRtcVoiceEngineTestFake, SetOptionOverridesViaChannels) {
// Make sure settings take effect while we are sending.
cricket::AudioSendParameters parameters_options_no_agc_nor_ns =
send_parameters_;
parameters_options_no_agc_nor_ns.options.auto_gain_control =
rtc::Optional<bool>(false);
parameters_options_no_agc_nor_ns.options.noise_suppression =
rtc::Optional<bool>(false);
parameters_options_no_agc_nor_ns.options.auto_gain_control = false;
parameters_options_no_agc_nor_ns.options.noise_suppression = false;
EXPECT_CALL(adm_, SetAGC(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, Enable(true)).WillOnce(Return(0));
EXPECT_CALL(apm_ec_, enable_metrics(true)).WillOnce(Return(0));
EXPECT_CALL(apm_gc_, Enable(false)).WillOnce(Return(0));
EXPECT_CALL(apm_ns_, Enable(false)).WillOnce(Return(0));
EXPECT_TRUE(channel2->SetSendParameters(parameters_options_no_agc_nor_ns));
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);
expected_options.echo_cancellation = true;
expected_options.auto_gain_control = false;
expected_options.noise_suppression = false;
EXPECT_EQ(expected_options, channel2->options());
}