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

(Auto)update libjingle 63777286-> 63837929

Browse Source 
git-svn-id: http://webrtc.googlecode.com/svn/trunk@5797 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
henrike@webrtc.org 2014-03-26 22:44:28 +00:00
parent b6dfbed1dc
commit b0ecc1c6fb
11 changed files with 250 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
talk/app/webrtc/mediaconstraintsinterface.cc
View File

@ -69,13 +69,6 @@ const char MediaConstraintsInterface::kNoiseReduction[] = "googNoiseReduction";
const char MediaConstraintsInterface::kLeakyBucket[] = "googLeakyBucket";
const char MediaConstraintsInterface::kTemporalLayeredScreencast[] =
"googTemporalLayeredScreencast";
// TODO(ronghuawu): Remove once cpu overuse detection is stable.
const char MediaConstraintsInterface::kCpuOveruseDetection[] =
"googCpuOveruseDetection";
const char MediaConstraintsInterface::kCpuUnderuseThreshold[] =
"googCpuUnderuseThreshold";
const char MediaConstraintsInterface::kCpuOveruseThreshold[] =
"googCpuOveruseThreshold";
// Google-specific PeerConnection constraint keys.
const char MediaConstraintsInterface::kImprovedWifiBwe[] =
@ -84,6 +77,15 @@ const char MediaConstraintsInterface::kScreencastMinBitrate[] =
"googScreencastMinBitrate";
const char MediaConstraintsInterface::kSkipEncodingUnusedStreams[] =
"googSkipEncodingUnusedStreams";
// TODO(ronghuawu): Remove once cpu overuse detection is stable.
const char MediaConstraintsInterface::kCpuOveruseDetection[] =
"googCpuOveruseDetection";
const char MediaConstraintsInterface::kCpuUnderuseThreshold[] =
"googCpuUnderuseThreshold";
const char MediaConstraintsInterface::kCpuOveruseThreshold[] =
"googCpuOveruseThreshold";
const char MediaConstraintsInterface::kCpuOveruseEncodeUsage[] =
"googCpuOveruseEncodeUsage";
// Constraint keys for CreateOffer / CreateAnswer defined in W3C specification.
const char MediaConstraintsInterface::kOfferToReceiveAudio[] =

7
talk/app/webrtc/mediaconstraintsinterface.h
View File

@ -90,15 +90,16 @@ class MediaConstraintsInterface {
// googTemporalLayeredScreencast
static const char kTemporalLayeredScreencast[];
static const char kCpuOveruseDetection[];
static const char kCpuUnderuseThreshold[];
static const char kCpuOveruseThreshold[];
// Google-specific PeerConnection constraint keys.
static const char kImprovedWifiBwe[]; // googImprovedWifiBwe
static const char kScreencastMinBitrate[]; // googScreencastMinBitrate
static const char kSkipEncodingUnusedStreams[];
// googSkipEncodingUnusedStreams
static const char kCpuOveruseDetection[];
static const char kCpuUnderuseThreshold[];
static const char kCpuOveruseThreshold[];
static const char kCpuOveruseEncodeUsage[];
// Constraint keys for CreateOffer / CreateAnswer
// Specified by the W3C PeerConnection spec

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

@ -181,13 +181,7 @@ bool NewFormatWithConstraints(
} else if (constraint.key == MediaConstraintsInterface::kNoiseReduction ||
constraint.key == MediaConstraintsInterface::kLeakyBucket ||
constraint.key ==
MediaConstraintsInterface::kTemporalLayeredScreencast ||
constraint.key ==
MediaConstraintsInterface::kCpuOveruseDetection ||
constraint.key ==
MediaConstraintsInterface::kCpuUnderuseThreshold ||
constraint.key ==
MediaConstraintsInterface::kCpuOveruseThreshold) {
MediaConstraintsInterface::kTemporalLayeredScreencast) {
// These are actually options, not constraints, so they can be satisfied
// regardless of the format.
return true;
@ -271,22 +265,6 @@ const cricket::VideoFormat& GetBestCaptureFormat(
return *best_it;
}
// Set |option| to the highest-priority value of |key| in the optional
// constraints if the key is found and has a valid value.
void ExtractOptionalOption(const MediaConstraintsInterface* all_constraints,
const std::string& key, cricket::Settable<int>* option) {
if (!all_constraints) {
return;
}
std::string string_value;
int value;
if (all_constraints->GetOptional().FindFirst(key, &string_value)) {
if (talk_base::FromString(string_value, &value)) {
option->Set(value);
}
}
}
// Set |option| to the highest-priority value of |key| in the constraints.
// Return false if the key is mandatory, and the value is invalid.
bool ExtractOption(const MediaConstraintsInterface* all_constraints,
@ -317,15 +295,6 @@ bool ExtractVideoOptions(const MediaConstraintsInterface* all_constraints,
all_valid &= ExtractOption(all_constraints,
MediaConstraintsInterface::kTemporalLayeredScreencast,
&(options->video_temporal_layer_screencast));
all_valid &= ExtractOption(all_constraints,
MediaConstraintsInterface::kCpuOveruseDetection,
&(options->cpu_overuse_detection));
ExtractOptionalOption(all_constraints,
MediaConstraintsInterface::kCpuUnderuseThreshold,
&(options->cpu_underuse_threshold));
ExtractOptionalOption(all_constraints,
MediaConstraintsInterface::kCpuOveruseThreshold,
&(options->cpu_overuse_threshold));
return all_valid;
}

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

@ -370,12 +370,6 @@ TEST_F(VideoSourceTest, SetValidOptionValues) {
MediaConstraintsInterface::kTemporalLayeredScreencast, "false");
constraints.AddOptional(
MediaConstraintsInterface::kLeakyBucket, "true");
constraints.AddOptional(
MediaConstraintsInterface::kCpuOveruseDetection, "true");
constraints.AddOptional(
MediaConstraintsInterface::kCpuUnderuseThreshold, 12);
constraints.AddOptional(
MediaConstraintsInterface::kCpuOveruseThreshold, 22);
CreateVideoSource(&constraints);
@ -387,12 +381,6 @@ TEST_F(VideoSourceTest, SetValidOptionValues) {
EXPECT_FALSE(value);
EXPECT_TRUE(source_->options()->video_leaky_bucket.Get(&value));
EXPECT_TRUE(value);
EXPECT_TRUE(source_->options()->
cpu_overuse_detection.GetWithDefaultIfUnset(false));
EXPECT_EQ(12, source_->options()->
cpu_underuse_threshold.GetWithDefaultIfUnset(23));
EXPECT_EQ(22, source_->options()->
cpu_overuse_threshold.GetWithDefaultIfUnset(23));
}
TEST_F(VideoSourceTest, OptionNotSet) {
@ -400,10 +388,6 @@ TEST_F(VideoSourceTest, OptionNotSet) {
CreateVideoSource(&constraints);
bool value;
EXPECT_FALSE(source_->options()->video_noise_reduction.Get(&value));
EXPECT_FALSE(source_->options()->cpu_overuse_detection.Get(&value));
int int_value;
EXPECT_FALSE(source_->options()->cpu_underuse_threshold.Get(&int_value));
EXPECT_FALSE(source_->options()->cpu_overuse_threshold.Get(&int_value));
}
TEST_F(VideoSourceTest, MandatoryOptionOverridesOptional) {
@ -456,10 +440,6 @@ TEST_F(VideoSourceTest, InvalidOptionValueOptional) {
MediaConstraintsInterface::kNoiseReduction, "true");
constraints.AddOptional(
MediaConstraintsInterface::kLeakyBucket, "not boolean");
constraints.AddOptional(
MediaConstraintsInterface::kCpuUnderuseThreshold, "12");
constraints.AddOptional(
MediaConstraintsInterface::kCpuOveruseThreshold, "not int");
CreateVideoSource(&constraints);
@ -469,10 +449,6 @@ TEST_F(VideoSourceTest, InvalidOptionValueOptional) {
EXPECT_TRUE(source_->options()->video_noise_reduction.Get(&value));
EXPECT_TRUE(value);
EXPECT_FALSE(source_->options()->video_leaky_bucket.Get(&value));
int int_value = 0;
EXPECT_TRUE(source_->options()->cpu_underuse_threshold.Get(&int_value));
EXPECT_EQ(12, int_value);
EXPECT_FALSE(source_->options()->cpu_overuse_threshold.Get(&int_value));
}
TEST_F(VideoSourceTest, InvalidOptionValueMandatory) {

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

@ -359,6 +359,23 @@ static std::string MakeTdErrorString(const std::string& desc) {
return MakeErrorString(kPushDownTDFailed, desc);
}
// Set |option| to the highest-priority value of |key| in the optional
// constraints if the key is found and has a valid value.
static void SetOptionFromOptionalConstraint(
const MediaConstraintsInterface* constraints,
const std::string& key, cricket::Settable<int>* option) {
if (!constraints) {
return;
}
std::string string_value;
int value;
if (constraints->GetOptional().FindFirst(key, &string_value)) {
if (talk_base::FromString(string_value, &value)) {
option->Set(value);
}
}
}
// Help class used to remember if a a remote peer has requested ice restart by
// by sending a description with new ice ufrag and password.
class IceRestartAnswerLatch {
@ -525,15 +542,31 @@ bool WebRtcSession::Initialize(
video_options_.skip_encoding_unused_streams.Set(value);
}
std::string string_value;
if (constraints &&
constraints->GetOptional().FindFirst(
MediaConstraintsInterface::kScreencastMinBitrate,
&string_value)) {
int bitrate;
if (talk_base::FromString(string_value, &bitrate)) {
video_options_.screencast_min_bitrate.Set(bitrate);
}
SetOptionFromOptionalConstraint(constraints,
MediaConstraintsInterface::kScreencastMinBitrate,
&video_options_.screencast_min_bitrate);
// Find constraints for cpu overuse detection.
SetOptionFromOptionalConstraint(constraints,
MediaConstraintsInterface::kCpuUnderuseThreshold,
&video_options_.cpu_underuse_threshold);
SetOptionFromOptionalConstraint(constraints,
MediaConstraintsInterface::kCpuOveruseThreshold,
&video_options_.cpu_overuse_threshold);
if (FindConstraint(
constraints,
MediaConstraintsInterface::kCpuOveruseDetection,
&value,
NULL)) {
video_options_.cpu_overuse_detection.Set(value);
}
if (FindConstraint(
constraints,
MediaConstraintsInterface::kCpuOveruseEncodeUsage,
&value,
NULL)) {
video_options_.cpu_overuse_encode_usage.Set(value);
}
// Find improved wifi bwe constraint.

2
talk/app/webrtc/webrtcsession.h
View File

@ -42,6 +42,7 @@
#include "talk/session/media/mediasession.h"
namespace cricket {
class BaseChannel;
class ChannelManager;
class DataChannel;
@ -50,6 +51,7 @@ class Transport;
class VideoCapturer;
class VideoChannel;
class VoiceChannel;
} // namespace cricket
namespace webrtc {

1
talk/base/win32toolhelp_unittest.cc
View File

@ -267,7 +267,6 @@ TEST_F(Win32ToolhelpTest, TestCurrentNextCalled) {
}
TEST_F(Win32ToolhelpTest, TestCurrentProcess) {
int size = MAX_PATH;
WCHAR buf[MAX_PATH];
GetModuleFileName(NULL, buf, ARRAY_SIZE(buf));
std::wstring name = ToUtf16(Pathname(ToUtf8(buf)).filename());

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

@ -317,6 +317,7 @@ struct VideoOptions {
cpu_overuse_detection.SetFrom(change.cpu_overuse_detection);
cpu_underuse_threshold.SetFrom(change.cpu_underuse_threshold);
cpu_overuse_threshold.SetFrom(change.cpu_overuse_threshold);
cpu_overuse_encode_usage.SetFrom(change.cpu_overuse_encode_usage);
conference_mode.SetFrom(change.conference_mode);
process_adaptation_threshhold.SetFrom(change.process_adaptation_threshhold);
system_low_adaptation_threshhold.SetFrom(
@ -352,6 +353,7 @@ struct VideoOptions {
cpu_overuse_detection == o.cpu_overuse_detection &&
cpu_underuse_threshold == o.cpu_underuse_threshold &&
cpu_overuse_threshold == o.cpu_overuse_threshold &&
cpu_overuse_encode_usage == o.cpu_overuse_encode_usage &&
conference_mode == o.conference_mode &&
process_adaptation_threshhold == o.process_adaptation_threshhold &&
system_low_adaptation_threshhold ==
@ -391,6 +393,8 @@ struct VideoOptions {
ost << ToStringIfSet("cpu overuse detection", cpu_overuse_detection);
ost << ToStringIfSet("cpu underuse threshold", cpu_underuse_threshold);
ost << ToStringIfSet("cpu overuse threshold", cpu_overuse_threshold);
ost << ToStringIfSet("cpu overuse encode usage",
cpu_overuse_encode_usage);
ost << ToStringIfSet("conference mode", conference_mode);
ost << ToStringIfSet("process", process_adaptation_threshhold);
ost << ToStringIfSet("low", system_low_adaptation_threshhold);
@ -446,6 +450,8 @@ struct VideoOptions {
Settable<int> cpu_underuse_threshold;
// High threshold for cpu overuse adaptation in ms. (Adapt down)
Settable<int> cpu_overuse_threshold;
// Use encode usage for cpu detection.
Settable<bool> cpu_overuse_encode_usage;
// Use conference mode?
Settable<bool> conference_mode;
// Threshhold for process cpu adaptation. (Process limit)

20
talk/media/webrtc/fakewebrtcvideoengine.h
View File

@ -300,6 +300,9 @@ class FakeWebRtcVideoEngine
overuse_observer_(NULL) {
ssrcs_[0] = 0; // default ssrc.
memset(&send_codec, 0, sizeof(send_codec));
#ifdef USE_WEBRTC_DEV_BRANCH
memset(&overuse_options_, 0, sizeof(overuse_options_));
#endif
}
int capture_id_;
int original_channel_id_;
@ -338,6 +341,9 @@ class FakeWebRtcVideoEngine
unsigned int receive_bandwidth_;
bool suspend_below_min_bitrate_;
webrtc::CpuOveruseObserver* overuse_observer_;
#ifdef USE_WEBRTC_DEV_BRANCH
webrtc::CpuOveruseOptions overuse_options_;
#endif
};
class Capturer : public webrtc::ViEExternalCapture {
public:
@ -539,6 +545,12 @@ class FakeWebRtcVideoEngine
WEBRTC_ASSERT_CHANNEL(channel);
return channels_.find(channel)->second->overuse_observer_;
}
#ifdef USE_WEBRTC_DEV_BRANCH
webrtc::CpuOveruseOptions GetCpuOveruseOptions(int channel) const {
WEBRTC_ASSERT_CHANNEL(channel);
return channels_.find(channel)->second->overuse_options_;
}
#endif
int GetRtxSsrc(int channel, int simulcast_idx) const {
WEBRTC_ASSERT_CHANNEL(channel);
if (channels_.find(channel)->second->rtx_ssrcs_.find(simulcast_idx) ==
@ -666,6 +678,14 @@ class FakeWebRtcVideoEngine
return 0;
}
WEBRTC_STUB(CpuOveruseMeasures, (int, int*, int*, int*, int*));
#ifdef USE_WEBRTC_DEV_BRANCH
WEBRTC_FUNC(SetCpuOveruseOptions,
(int channel, const webrtc::CpuOveruseOptions& options)) {
WEBRTC_CHECK_CHANNEL(channel);
channels_[channel]->overuse_options_ = options;
return 0;
}
#endif
WEBRTC_STUB(ConnectAudioChannel, (const int, const int));
WEBRTC_STUB(DisconnectAudioChannel, (const int));
WEBRTC_FUNC(StartSend, (const int channel)) {

52
talk/media/webrtc/webrtcvideoengine.cc
View File

@ -842,6 +842,38 @@ static void UpdateVideoCodec(const cricket::VideoFormat& video_format,
video_format.interval);
}
#ifdef USE_WEBRTC_DEV_BRANCH
static bool GetCpuOveruseOptions(const VideoOptions& options,
webrtc::CpuOveruseOptions* overuse_options) {
int underuse_threshold = 0;
int overuse_threshold = 0;
if (!options.cpu_underuse_threshold.Get(&underuse_threshold) ||
!options.cpu_overuse_threshold.Get(&overuse_threshold)) {
return false;
}
if (underuse_threshold <= 0 || overuse_threshold <= 0) {
return false;
}
// Valid thresholds.
bool encode_usage =
options.cpu_overuse_encode_usage.GetWithDefaultIfUnset(false);
overuse_options->enable_capture_jitter_method = !encode_usage;
overuse_options->enable_encode_usage_method = encode_usage;
if (encode_usage) {
// Use method based on encode usage.
overuse_options->low_encode_usage_threshold_percent = underuse_threshold;
overuse_options->high_encode_usage_threshold_percent = overuse_threshold;
} else {
// Use default method based on capture jitter.
overuse_options->low_capture_jitter_threshold_ms =
static_cast<float>(underuse_threshold);
overuse_options->high_capture_jitter_threshold_ms =
static_cast<float>(overuse_threshold);
}
return true;
}
#endif
WebRtcVideoEngine::WebRtcVideoEngine() {
Construct(new ViEWrapper(), new ViETraceWrapper(), NULL,
new talk_base::CpuMonitor(NULL));
@ -2981,6 +3013,16 @@ bool WebRtcVideoMediaChannel::SetOptions(const VideoOptions &options) {
it->second->channel_id(), config);
}
}
webrtc::CpuOveruseOptions overuse_options;
if (GetCpuOveruseOptions(options_, &overuse_options)) {
for (SendChannelMap::iterator it = send_channels_.begin();
it != send_channels_.end(); ++it) {
if (engine()->vie()->base()->SetCpuOveruseOptions(
it->second->channel_id(), overuse_options) != 0) {
LOG_RTCERR1(SetCpuOveruseOptions, it->second->channel_id());
}
}
}
#endif
return true;
}
@ -3414,6 +3456,16 @@ bool WebRtcVideoMediaChannel::ConfigureSending(int channel_id,
send_channel->SetCpuOveruseDetection(true);
}
#ifdef USE_WEBRTC_DEV_BRANCH
webrtc::CpuOveruseOptions overuse_options;
if (GetCpuOveruseOptions(options_, &overuse_options)) {
if (engine()->vie()->base()->SetCpuOveruseOptions(channel_id,
overuse_options) != 0) {
LOG_RTCERR1(SetCpuOveruseOptions, channel_id);
}
}
#endif
// Register encoder observer for outgoing framerate and bitrate.
if (engine()->vie()->codec()->RegisterEncoderObserver(
channel_id, *send_channel->encoder_observer()) != 0) {

114
talk/media/webrtc/webrtcvideoengine_unittest.cc
View File

@ -920,6 +920,120 @@ TEST_F(WebRtcVideoEngineTestFake, AdditiveVideoOptions) {
EXPECT_TRUE(vie_.GetTransmissionSmoothingStatus(first_send_channel));
}
#ifdef USE_WEBRTC_DEV_BRANCH
TEST_F(WebRtcVideoEngineTestFake, SetCpuOveruseOptionsWithCaptureJitterMethod) {
EXPECT_TRUE(SetupEngine());
// Verify this is off by default.
EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1)));
int first_send_channel = vie_.GetLastChannel();
webrtc::CpuOveruseOptions cpu_option =
vie_.GetCpuOveruseOptions(first_send_channel);
EXPECT_EQ(0, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(0, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
// Set low and high threshold and verify that cpu options are set.
cricket::VideoOptions options;
options.conference_mode.Set(true);
options.cpu_underuse_threshold.Set(10);
options.cpu_overuse_threshold.Set(20);
EXPECT_TRUE(channel_->SetOptions(options));
cpu_option = vie_.GetCpuOveruseOptions(first_send_channel);
EXPECT_EQ(10, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(20, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_TRUE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
// Add a receive channel and verify that cpu options are not set.
EXPECT_TRUE(channel_->AddRecvStream(cricket::StreamParams::CreateLegacy(2)));
int recv_channel_num = vie_.GetLastChannel();
EXPECT_NE(first_send_channel, recv_channel_num);
cpu_option = vie_.GetCpuOveruseOptions(recv_channel_num);
EXPECT_EQ(0, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(0, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
// Add a new send stream and verify that cpu options are set from start.
EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(3)));
int second_send_channel = vie_.GetLastChannel();
EXPECT_NE(first_send_channel, second_send_channel);
cpu_option = vie_.GetCpuOveruseOptions(second_send_channel);
EXPECT_EQ(10, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(20, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_TRUE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
}
TEST_F(WebRtcVideoEngineTestFake, SetInvalidCpuOveruseThresholds) {
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1)));
int channel_num = vie_.GetLastChannel();
// Only low threshold set. Verify that cpu options are not set.
cricket::VideoOptions options;
options.conference_mode.Set(true);
options.cpu_underuse_threshold.Set(10);
EXPECT_TRUE(channel_->SetOptions(options));
webrtc::CpuOveruseOptions cpu_option = vie_.GetCpuOveruseOptions(channel_num);
EXPECT_EQ(0, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(0, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
// Set high threshold to a negative value. Verify that options are not set.
options.cpu_overuse_threshold.Set(-1);
EXPECT_TRUE(channel_->SetOptions(options));
cpu_option = vie_.GetCpuOveruseOptions(channel_num);
EXPECT_EQ(0, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(0, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
// Low and high threshold valid. Verify that cpu options are set.
options.cpu_overuse_threshold.Set(20);
EXPECT_TRUE(channel_->SetOptions(options));
cpu_option = vie_.GetCpuOveruseOptions(channel_num);
EXPECT_EQ(10, cpu_option.low_capture_jitter_threshold_ms);
EXPECT_EQ(20, cpu_option.high_capture_jitter_threshold_ms);
EXPECT_TRUE(cpu_option.enable_capture_jitter_method);
EXPECT_FALSE(cpu_option.enable_encode_usage_method);
}
TEST_F(WebRtcVideoEngineTestFake, SetCpuOveruseOptionsWithEncodeUsageMethod) {
EXPECT_TRUE(SetupEngine());
EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(1)));
int first_send_channel = vie_.GetLastChannel();
// Set low and high threshold and enable encode usage method.
// Verify that cpu options are set.
cricket::VideoOptions options;
options.conference_mode.Set(true);
options.cpu_underuse_threshold.Set(10);
options.cpu_overuse_threshold.Set(20);
options.cpu_overuse_encode_usage.Set(true);
EXPECT_TRUE(channel_->SetOptions(options));
webrtc::CpuOveruseOptions cpu_option =
vie_.GetCpuOveruseOptions(first_send_channel);
EXPECT_EQ(10, cpu_option.low_encode_usage_threshold_percent);
EXPECT_EQ(20, cpu_option.high_encode_usage_threshold_percent);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_TRUE(cpu_option.enable_encode_usage_method);
// Add a new send stream and verify that cpu options are set from start.
EXPECT_TRUE(channel_->AddSendStream(cricket::StreamParams::CreateLegacy(3)));
int second_send_channel = vie_.GetLastChannel();
EXPECT_NE(first_send_channel, second_send_channel);
cpu_option = vie_.GetCpuOveruseOptions(second_send_channel);
EXPECT_EQ(10, cpu_option.low_encode_usage_threshold_percent);
EXPECT_EQ(20, cpu_option.high_encode_usage_threshold_percent);
EXPECT_FALSE(cpu_option.enable_capture_jitter_method);
EXPECT_TRUE(cpu_option.enable_encode_usage_method);
}
#endif
// Test that AddRecvStream doesn't create new channel for 1:1 call.
TEST_F(WebRtcVideoEngineTestFake, AddRecvStream1On1) {
EXPECT_TRUE(SetupEngine());