Step 1 to prepare call_test.* for combined audio/video tests.
Also move (and clean up includes) rampup_tests.* to webrtc/call in preparation for combined audio/video ramp-up tests.
No functional changes.
BUG=webrtc:5263
Review URL: https://codereview.webrtc.org/1537273003
Cr-Commit-Position: refs/heads/master@{#11101}
diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc
index d8c0d5e..e371270 100644
--- a/webrtc/call/bitrate_estimator_tests.cc
+++ b/webrtc/call/bitrate_estimator_tests.cc
@@ -119,17 +119,17 @@
receive_transport_.reset(new test::DirectTransport(receiver_call_.get()));
receive_transport_->SetReceiver(sender_call_->Receiver());
- send_config_ = VideoSendStream::Config(send_transport_.get());
- send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
+ video_send_config_ = VideoSendStream::Config(send_transport_.get());
+ video_send_config_.rtp.ssrcs.push_back(kSendSsrcs[0]);
// Encoders will be set separately per stream.
- send_config_.encoder_settings.encoder = nullptr;
- send_config_.encoder_settings.payload_name = "FAKE";
- send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
- encoder_config_.streams = test::CreateVideoStreams(1);
+ video_send_config_.encoder_settings.encoder = nullptr;
+ video_send_config_.encoder_settings.payload_name = "FAKE";
+ video_send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
+ video_encoder_config_.streams = test::CreateVideoStreams(1);
receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately.
- receive_config_.rtp.remote_ssrc = send_config_.rtp.ssrcs[0];
+ receive_config_.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[0];
receive_config_.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config_.rtp.remb = true;
receive_config_.rtp.extensions.push_back(
@@ -168,21 +168,21 @@
frame_generator_capturer_(),
fake_encoder_(Clock::GetRealTimeClock()),
fake_decoder_() {
- test_->send_config_.rtp.ssrcs[0]++;
- test_->send_config_.encoder_settings.encoder = &fake_encoder_;
+ test_->video_send_config_.rtp.ssrcs[0]++;
+ test_->video_send_config_.encoder_settings.encoder = &fake_encoder_;
send_stream_ = test_->sender_call_->CreateVideoSendStream(
- test_->send_config_, test_->encoder_config_);
- RTC_DCHECK_EQ(1u, test_->encoder_config_.streams.size());
+ test_->video_send_config_, test_->video_encoder_config_);
+ RTC_DCHECK_EQ(1u, test_->video_encoder_config_.streams.size());
frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
- send_stream_->Input(), test_->encoder_config_.streams[0].width,
- test_->encoder_config_.streams[0].height, 30,
+ send_stream_->Input(), test_->video_encoder_config_.streams[0].width,
+ test_->video_encoder_config_.streams[0].height, 30,
Clock::GetRealTimeClock()));
send_stream_->Start();
frame_generator_capturer_->Start();
if (receive_audio) {
AudioReceiveStream::Config receive_config;
- receive_config.rtp.remote_ssrc = test_->send_config_.rtp.ssrcs[0];
+ receive_config.rtp.remote_ssrc = test_->video_send_config_.rtp.ssrcs[0];
// Bogus non-default id to prevent hitting a RTC_DCHECK when creating
// the AudioReceiveStream. Every receive stream has to correspond to
// an underlying channel id.
@@ -196,13 +196,13 @@
VideoReceiveStream::Decoder decoder;
decoder.decoder = &fake_decoder_;
decoder.payload_type =
- test_->send_config_.encoder_settings.payload_type;
+ test_->video_send_config_.encoder_settings.payload_type;
decoder.payload_name =
- test_->send_config_.encoder_settings.payload_name;
+ test_->video_send_config_.encoder_settings.payload_name;
test_->receive_config_.decoders.clear();
test_->receive_config_.decoders.push_back(decoder);
test_->receive_config_.rtp.remote_ssrc =
- test_->send_config_.rtp.ssrcs[0];
+ test_->video_send_config_.rtp.ssrcs[0];
test_->receive_config_.rtp.local_ssrc++;
video_receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream(
test_->receive_config_);
@@ -264,7 +264,7 @@
"RemoteBitrateEstimatorSingleStream: Instantiating.";
TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@@ -273,7 +273,7 @@
}
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForAudio) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@@ -284,7 +284,7 @@
}
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
@@ -300,7 +300,7 @@
streams_.push_back(new Stream(this, true));
EXPECT_TRUE(receiver_log_.Wait());
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId));
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
@@ -309,14 +309,14 @@
}
TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
streams_.push_back(new Stream(this, false));
EXPECT_TRUE(receiver_log_.Wait());
- send_config_.rtp.extensions[0] =
+ video_send_config_.rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
@@ -325,21 +325,21 @@
}
TEST_F(BitrateEstimatorTest, SwitchesToASTThenBackToTOFForVideo) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
streams_.push_back(new Stream(this, false));
EXPECT_TRUE(receiver_log_.Wait());
- send_config_.rtp.extensions[0] =
+ video_send_config_.rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTime, kASTExtensionId);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
streams_.push_back(new Stream(this, false));
EXPECT_TRUE(receiver_log_.Wait());
- send_config_.rtp.extensions[0] =
+ video_send_config_.rtp.extensions[0] =
RtpExtension(RtpExtension::kTOffset, kTOFExtensionId);
receiver_log_.PushExpectedLogLine(
"WrappingBitrateEstimator: Switching to transmission time offset RBE.");
diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc
index c918f0e..faefc42 100644
--- a/webrtc/call/call_perf_tests.cc
+++ b/webrtc/call/call_perf_tests.cc
@@ -296,16 +296,16 @@
CodecInst isac = {103, "ISAC", 16000, 480, 1, 32000};
EXPECT_EQ(0, voe_codec->SetSendCodec(send_channel_id, isac));
- send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
if (fec) {
- send_config_.rtp.fec.red_payload_type = kRedPayloadType;
- send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
- receive_configs_[0].rtp.fec.red_payload_type = kRedPayloadType;
- receive_configs_[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+ video_send_config_.rtp.fec.red_payload_type = kRedPayloadType;
+ video_send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
+ video_receive_configs_[0].rtp.fec.red_payload_type = kRedPayloadType;
+ video_receive_configs_[0].rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
}
- receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
- receive_configs_[0].renderer = &observer;
- receive_configs_[0].sync_group = kSyncGroup;
+ video_receive_configs_[0].rtp.nack.rtp_history_ms = 1000;
+ video_receive_configs_[0].renderer = &observer;
+ video_receive_configs_[0].sync_group = kSyncGroup;
AudioReceiveStream::Config audio_recv_config;
audio_recv_config.rtp.remote_ssrc = kAudioSendSsrc;
@@ -464,9 +464,10 @@
capturer_ = frame_generator_capturer;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].renderer = this;
// Enable the receiver side rtt calculation.
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
@@ -531,9 +532,10 @@
observation_complete_.Set();
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->overuse_callback = this;
send_config->encoder_settings.encoder = &encoder_;
}
@@ -613,15 +615,16 @@
return SEND_PACKET;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
if (pad_to_min_bitrate_) {
encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
} else {
@@ -698,9 +701,10 @@
return config;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
encoder_config->streams[0].min_bitrate_bps = 50000;
encoder_config->streams[0].target_bitrate_bps =
@@ -709,7 +713,7 @@
encoder_config_ = *encoder_config;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
diff --git a/webrtc/call/packet_injection_tests.cc b/webrtc/call/packet_injection_tests.cc
index 18ca058..315fc7b 100644
--- a/webrtc/call/packet_injection_tests.cc
+++ b/webrtc/call/packet_injection_tests.cc
@@ -42,13 +42,13 @@
test::NullTransport null_transport;
CreateSendConfig(1, &null_transport);
CreateMatchingReceiveConfigs(&null_transport);
- receive_configs_[0].decoders[0].payload_type = payload_type;
+ video_receive_configs_[0].decoders[0].payload_type = payload_type;
switch (codec_type) {
case CodecType::kVp8:
- receive_configs_[0].decoders[0].payload_name = "VP8";
+ video_receive_configs_[0].decoders[0].payload_name = "VP8";
break;
case CodecType::kH264:
- receive_configs_[0].decoders[0].payload_name = "H264";
+ video_receive_configs_[0].decoders[0].payload_name = "H264";
break;
}
CreateStreams();
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/call/rampup_tests.cc
similarity index 78%
rename from webrtc/video/rampup_tests.cc
rename to webrtc/call/rampup_tests.cc
index bc5daf5..ace90f4 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/call/rampup_tests.cc
@@ -8,31 +8,19 @@
* be found in the AUTHORS file in the root of the source tree.
*/
+#include "webrtc/call/rampup_tests.h"
+
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/checks.h"
-#include "webrtc/base/common.h"
-#include "webrtc/base/event.h"
#include "webrtc/base/platform_thread.h"
-#include "webrtc/modules/pacing/packet_router.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
-#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
-#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_payload_registry.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/test/testsupport/perf_test.h"
-#include "webrtc/video/rampup_tests.h"
namespace webrtc {
namespace {
static const int64_t kPollIntervalMs = 20;
-std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
- uint32_t ssrc_offset) {
+std::vector<uint32_t> GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) {
std::vector<uint32_t> ssrcs;
for (size_t i = 0; i != num_streams; ++i)
ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
@@ -40,7 +28,8 @@
}
} // namespace
-RampUpTester::RampUpTester(size_t num_streams,
+RampUpTester::RampUpTester(size_t num_video_streams,
+ size_t num_audio_streams,
unsigned int start_bitrate_bps,
const std::string& extension_type,
bool rtx,
@@ -48,7 +37,8 @@
: EndToEndTest(test::CallTest::kLongTimeoutMs),
event_(false, false),
clock_(Clock::GetRealTimeClock()),
- num_streams_(num_streams),
+ num_video_streams_(num_video_streams),
+ num_audio_streams_(num_audio_streams),
rtx_(rtx),
red_(red),
send_stream_(nullptr),
@@ -58,15 +48,16 @@
test_start_ms_(-1),
ramp_up_finished_ms_(-1),
extension_type_(extension_type),
- ssrcs_(GenerateSsrcs(num_streams, 100)),
- rtx_ssrcs_(GenerateSsrcs(num_streams, 200)),
+ video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
+ video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
+ audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
poller_thread_(&BitrateStatsPollingThread,
this,
"BitrateStatsPollingThread"),
sender_call_(nullptr) {
if (rtx_) {
- for (size_t i = 0; i < ssrcs_.size(); ++i)
- rtx_ssrc_map_[rtx_ssrcs_[i]] = ssrcs_[i];
+ for (size_t i = 0; i < video_ssrcs_.size(); ++i)
+ rtx_ssrc_map_[video_rtx_ssrcs_[i]] = video_ssrcs_[i];
}
}
@@ -83,7 +74,7 @@
return call_config;
}
-void RampUpTester::OnStreamsCreated(
+void RampUpTester::OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) {
send_stream_ = send_stream;
@@ -96,17 +87,13 @@
send_transport_->SetConfig(forward_transport_config_);
}
-size_t RampUpTester::GetNumStreams() const {
- return num_streams_;
-}
-
-void RampUpTester::ModifyConfigs(
+void RampUpTester::ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) {
send_config->suspend_below_min_bitrate = true;
- if (num_streams_ == 1) {
+ if (num_video_streams_ == 1) {
encoder_config->streams[0].target_bitrate_bps =
encoder_config->streams[0].max_bitrate_bps = 2000000;
// For single stream rampup until 1mbps
@@ -143,10 +130,10 @@
}
send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
- send_config->rtp.ssrcs = ssrcs_;
+ send_config->rtp.ssrcs = video_ssrcs_;
if (rtx_) {
send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
- send_config->rtp.rtx.ssrcs = rtx_ssrcs_;
+ send_config->rtp.rtx.ssrcs = video_rtx_ssrcs_;
}
if (red_) {
send_config->rtp.fec.ulpfec_payload_type =
@@ -160,7 +147,7 @@
recv_config.rtp.transport_cc = transport_cc;
recv_config.rtp.extensions = send_config->rtp.extensions;
- recv_config.rtp.remote_ssrc = ssrcs_[i];
+ recv_config.rtp.remote_ssrc = video_ssrcs_[i];
recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms;
if (red_) {
@@ -172,7 +159,7 @@
if (rtx_) {
recv_config.rtp.rtx[send_config->encoder_settings.payload_type].ssrc =
- rtx_ssrcs_[i];
+ video_rtx_ssrcs_[i];
recv_config.rtp.rtx[send_config->encoder_settings.payload_type]
.payload_type = send_config->rtp.rtx.payload_type;
}
@@ -216,8 +203,8 @@
const std::string& units) const {
webrtc::test::PrintResult(
measurement, "",
- ::testing::UnitTest::GetInstance()->current_test_info()->name(),
- value, units, false);
+ ::testing::UnitTest::GetInstance()->current_test_info()->name(), value,
+ units, false);
}
void RampUpTester::AccumulateStats(const VideoSendStream::StreamStats& stream,
@@ -246,7 +233,7 @@
size_t total_sent = 0;
size_t padding_sent = 0;
size_t media_sent = 0;
- for (uint32_t ssrc : ssrcs_) {
+ for (uint32_t ssrc : video_ssrcs_) {
AccumulateStats(send_stats.substreams[ssrc], &total_packets_sent,
&total_sent, &padding_sent, &media_sent);
}
@@ -255,7 +242,7 @@
size_t rtx_total_sent = 0;
size_t rtx_padding_sent = 0;
size_t rtx_media_sent = 0;
- for (uint32_t rtx_ssrc : rtx_ssrcs_) {
+ for (uint32_t rtx_ssrc : video_rtx_ssrcs_) {
AccumulateStats(send_stats.substreams[rtx_ssrc], &rtx_total_packets_sent,
&rtx_total_sent, &rtx_padding_sent, &rtx_media_sent);
}
@@ -288,13 +275,12 @@
const std::string& extension_type,
bool rtx,
bool red)
- : RampUpTester(num_streams, start_bitrate_bps, extension_type, rtx, red),
+ : RampUpTester(num_streams, 0, start_bitrate_bps, extension_type, rtx, red),
test_state_(kFirstRampup),
state_start_ms_(clock_->TimeInMilliseconds()),
interval_start_ms_(clock_->TimeInMilliseconds()),
sent_bytes_(0) {
- forward_transport_config_.link_capacity_kbps =
- kHighBandwidthLimitBps / 1000;
+ forward_transport_config_.link_capacity_kbps = kHighBandwidthLimitBps / 1000;
}
RampUpDownUpTester::~RampUpDownUpTester() {}
@@ -321,12 +307,22 @@
std::string RampUpDownUpTester::GetModifierString() const {
std::string str("_");
- std::ostringstream s;
- s << num_streams_;
- str += s.str();
- str += "stream";
- str += (num_streams_ > 1 ? "s" : "");
- str += "_";
+ if (num_video_streams_ > 0) {
+ std::ostringstream s;
+ s << num_video_streams_;
+ str += s.str();
+ str += "stream";
+ str += (num_video_streams_ > 1 ? "s" : "");
+ str += "_";
+ }
+ if (num_audio_streams_ > 0) {
+ std::ostringstream s;
+ s << num_audio_streams_;
+ str += s.str();
+ str += "stream";
+ str += (num_audio_streams_ > 1 ? "s" : "");
+ str += "_";
+ }
str += (rtx_ ? "" : "no");
str += "rtx";
return str;
@@ -344,11 +340,8 @@
kLowBandwidthLimitBps / 1000;
send_transport_->SetConfig(forward_transport_config_);
test_state_ = kLowRate;
- webrtc::test::PrintResult("ramp_up_down_up",
- GetModifierString(),
- "first_rampup",
- now - state_start_ms_,
- "ms",
+ webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+ "first_rampup", now - state_start_ms_, "ms",
false);
state_start_ms_ = now;
interval_start_ms_ = now;
@@ -364,11 +357,8 @@
kHighBandwidthLimitBps / 1000;
send_transport_->SetConfig(forward_transport_config_);
test_state_ = kSecondRampup;
- webrtc::test::PrintResult("ramp_up_down_up",
- GetModifierString(),
- "rampdown",
- now - state_start_ms_,
- "ms",
+ webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+ "rampdown", now - state_start_ms_, "ms",
false);
state_start_ms_ = now;
interval_start_ms_ = now;
@@ -378,11 +368,8 @@
}
case kSecondRampup: {
if (bitrate_bps > kExpectedHighBitrateBps && !suspended) {
- webrtc::test::PrintResult("ramp_up_down_up",
- GetModifierString(),
- "second_rampup",
- now - state_start_ms_,
- "ms",
+ webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+ "second_rampup", now - state_start_ms_, "ms",
false);
observation_complete_.Set();
}
@@ -396,33 +383,33 @@
RampUpTest() {}
virtual ~RampUpTest() {
- EXPECT_EQ(nullptr, send_stream_);
- EXPECT_TRUE(receive_streams_.empty());
+ EXPECT_EQ(nullptr, video_send_stream_);
+ EXPECT_TRUE(video_receive_streams_.empty());
}
};
TEST_F(RampUpTest, SingleStream) {
- RampUpTester test(1, 0, RtpExtension::kTOffset, false, false);
+ RampUpTester test(1, 0, 0, RtpExtension::kTOffset, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, Simulcast) {
- RampUpTester test(3, 0, RtpExtension::kTOffset, false, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kTOffset, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SimulcastWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kTOffset, true, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kTOffset, true, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SimulcastByRedWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kTOffset, true, true);
+ RampUpTester test(3, 0, 0, RtpExtension::kTOffset, true, true);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
- RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
+ RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
@@ -458,53 +445,57 @@
}
TEST_F(RampUpTest, AbsSendTimeSingleStream) {
- RampUpTester test(1, 0, RtpExtension::kAbsSendTime, false, false);
+ RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcast) {
- RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, true, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true);
+ RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, true, true);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
- RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
- false, false);
+ RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
+ RtpExtension::kAbsSendTime, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
- RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
+ RampUpTester test(1, 0, 0, RtpExtension::kTransportSequenceNumber, false,
+ false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
- RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, false,
+ false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
+ RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
+ false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
- RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
+ RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
+ true);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
- RampUpTester test(1, 0.9 * kSingleStreamTargetBps,
+ RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
RtpExtension::kTransportSequenceNumber, false, false);
RunBaseTest(&test, FakeNetworkPipe::Config());
}
diff --git a/webrtc/video/rampup_tests.h b/webrtc/call/rampup_tests.h
similarity index 82%
rename from webrtc/video/rampup_tests.h
rename to webrtc/call/rampup_tests.h
index 81159e6..561ed0d 100644
--- a/webrtc/video/rampup_tests.h
+++ b/webrtc/call/rampup_tests.h
@@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
-#ifndef WEBRTC_VIDEO_RAMPUP_TESTS_H_
-#define WEBRTC_VIDEO_RAMPUP_TESTS_H_
+#ifndef WEBRTC_CALL_RAMPUP_TESTS_H_
+#define WEBRTC_CALL_RAMPUP_TESTS_H_
#include <map>
#include <string>
@@ -18,8 +18,6 @@
#include "webrtc/base/event.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/call.h"
-#include "webrtc/call/transport_adapter.h"
-#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
#include "webrtc/test/call_test.h"
namespace webrtc {
@@ -30,15 +28,11 @@
static const unsigned int kSingleStreamTargetBps = 1000000;
class Clock;
-class PacketRouter;
-class ReceiveStatistics;
-class RtpHeaderParser;
-class RTPPayloadRegistry;
-class RtpRtcp;
class RampUpTester : public test::EndToEndTest {
public:
- RampUpTester(size_t num_streams,
+ RampUpTester(size_t num_video_streams,
+ size_t num_audio_streams,
unsigned int start_bitrate_bps,
const std::string& extension_type,
bool rtx,
@@ -64,7 +58,8 @@
rtc::Event event_;
Clock* const clock_;
FakeNetworkPipe::Config forward_transport_config_;
- const size_t num_streams_;
+ const size_t num_video_streams_;
+ const size_t num_audio_streams_;
const bool rtx_;
const bool red_;
VideoSendStream* send_stream_;
@@ -74,15 +69,15 @@
typedef std::map<uint32_t, uint32_t> SsrcMap;
Call::Config GetSenderCallConfig() override;
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
void OnTransportsCreated(test::PacketTransport* send_transport,
test::PacketTransport* receive_transport) override;
- size_t GetNumStreams() const;
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override;
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override;
void OnCallsCreated(Call* sender_call, Call* receiver_call) override;
static bool BitrateStatsPollingThread(void* obj);
@@ -94,8 +89,9 @@
int64_t ramp_up_finished_ms_;
const std::string extension_type_;
- std::vector<uint32_t> ssrcs_;
- std::vector<uint32_t> rtx_ssrcs_;
+ std::vector<uint32_t> video_ssrcs_;
+ std::vector<uint32_t> video_rtx_ssrcs_;
+ std::vector<uint32_t> audio_ssrcs_;
SsrcMap rtx_ssrc_map_;
rtc::PlatformThread poller_thread_;
@@ -132,4 +128,4 @@
int sent_bytes_;
};
} // namespace webrtc
-#endif // WEBRTC_VIDEO_RAMPUP_TESTS_H_
+#endif // WEBRTC_CALL_RAMPUP_TESTS_H_
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index 5caae13..bbc1224 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -19,10 +19,9 @@
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
- send_config_(nullptr),
- send_stream_(NULL),
- fake_encoder_(clock_) {
-}
+ video_send_config_(nullptr),
+ video_send_stream_(NULL),
+ fake_encoder_(clock_) {}
CallTest::~CallTest() {
}
@@ -52,9 +51,10 @@
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs(receive_transport_.get());
}
- test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
+ test->ModifyVideoConfigs(&video_send_config_, &video_receive_configs_,
+ &video_encoder_config_);
CreateStreams();
- test->OnStreamsCreated(send_stream_, receive_streams_);
+ test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
CreateFrameGeneratorCapturer();
test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
@@ -69,9 +69,9 @@
}
void CallTest::Start() {
- send_stream_->Start();
- for (size_t i = 0; i < receive_streams_.size(); ++i)
- receive_streams_[i]->Start();
+ video_send_stream_->Start();
+ for (size_t i = 0; i < video_receive_streams_.size(); ++i)
+ video_receive_streams_[i]->Start();
if (frame_generator_capturer_.get() != NULL)
frame_generator_capturer_->Start();
}
@@ -79,9 +79,9 @@
void CallTest::Stop() {
if (frame_generator_capturer_.get() != NULL)
frame_generator_capturer_->Stop();
- for (size_t i = 0; i < receive_streams_.size(); ++i)
- receive_streams_[i]->Stop();
- send_stream_->Stop();
+ for (size_t i = 0; i < video_receive_streams_.size(); ++i)
+ video_receive_streams_[i]->Stop();
+ video_send_stream_->Stop();
}
void CallTest::CreateCalls(const Call::Config& sender_config,
@@ -106,70 +106,67 @@
void CallTest::CreateSendConfig(size_t num_streams,
Transport* send_transport) {
assert(num_streams <= kNumSsrcs);
- send_config_ = VideoSendStream::Config(send_transport);
- send_config_.encoder_settings.encoder = &fake_encoder_;
- send_config_.encoder_settings.payload_name = "FAKE";
- send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
- send_config_.rtp.extensions.push_back(
+ video_send_config_ = VideoSendStream::Config(send_transport);
+ video_send_config_.encoder_settings.encoder = &fake_encoder_;
+ video_send_config_.encoder_settings.payload_name = "FAKE";
+ video_send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
- encoder_config_.streams = test::CreateVideoStreams(num_streams);
+ video_encoder_config_.streams = test::CreateVideoStreams(num_streams);
for (size_t i = 0; i < num_streams; ++i)
- send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kVideoRotation, kVideoRotationRtpExtensionId));
}
void CallTest::CreateMatchingReceiveConfigs(
Transport* rtcp_send_transport) {
- assert(!send_config_.rtp.ssrcs.empty());
- assert(receive_configs_.empty());
+ assert(!video_send_config_.rtp.ssrcs.empty());
+ assert(video_receive_configs_.empty());
assert(allocated_decoders_.empty());
VideoReceiveStream::Config config(rtcp_send_transport);
config.rtp.remb = true;
config.rtp.local_ssrc = kReceiverLocalSsrc;
- for (const RtpExtension& extension : send_config_.rtp.extensions)
+ for (const RtpExtension& extension : video_send_config_.rtp.extensions)
config.rtp.extensions.push_back(extension);
- for (size_t i = 0; i < send_config_.rtp.ssrcs.size(); ++i) {
+ for (size_t i = 0; i < video_send_config_.rtp.ssrcs.size(); ++i) {
VideoReceiveStream::Decoder decoder =
- test::CreateMatchingDecoder(send_config_.encoder_settings);
+ test::CreateMatchingDecoder(video_send_config_.encoder_settings);
allocated_decoders_.push_back(decoder.decoder);
config.decoders.clear();
config.decoders.push_back(decoder);
- config.rtp.remote_ssrc = send_config_.rtp.ssrcs[i];
- receive_configs_.push_back(config);
+ config.rtp.remote_ssrc = video_send_config_.rtp.ssrcs[i];
+ video_receive_configs_.push_back(config);
}
}
void CallTest::CreateFrameGeneratorCapturer() {
- VideoStream stream = encoder_config_.streams.back();
- frame_generator_capturer_.reset(
- test::FrameGeneratorCapturer::Create(send_stream_->Input(),
- stream.width,
- stream.height,
- stream.max_framerate,
- clock_));
+ VideoStream stream = video_encoder_config_.streams.back();
+ frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
+ video_send_stream_->Input(), stream.width, stream.height,
+ stream.max_framerate, clock_));
}
void CallTest::CreateStreams() {
- assert(send_stream_ == NULL);
- assert(receive_streams_.empty());
+ assert(video_send_stream_ == NULL);
+ assert(video_receive_streams_.empty());
- send_stream_ =
- sender_call_->CreateVideoSendStream(send_config_, encoder_config_);
+ video_send_stream_ = sender_call_->CreateVideoSendStream(
+ video_send_config_, video_encoder_config_);
- for (size_t i = 0; i < receive_configs_.size(); ++i) {
- receive_streams_.push_back(
- receiver_call_->CreateVideoReceiveStream(receive_configs_[i]));
+ for (size_t i = 0; i < video_receive_configs_.size(); ++i) {
+ video_receive_streams_.push_back(
+ receiver_call_->CreateVideoReceiveStream(video_receive_configs_[i]));
}
}
void CallTest::DestroyStreams() {
- if (send_stream_ != NULL)
- sender_call_->DestroyVideoSendStream(send_stream_);
- send_stream_ = NULL;
- for (size_t i = 0; i < receive_streams_.size(); ++i)
- receiver_call_->DestroyVideoReceiveStream(receive_streams_[i]);
- receive_streams_.clear();
+ if (video_send_stream_ != NULL)
+ sender_call_->DestroyVideoSendStream(video_send_stream_);
+ video_send_stream_ = NULL;
+ for (size_t i = 0; i < video_receive_streams_.size(); ++i)
+ receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[i]);
+ video_receive_streams_.clear();
allocated_decoders_.clear();
}
@@ -211,16 +208,14 @@
return 1;
}
-void BaseTest::ModifyConfigs(
+void BaseTest::ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) {
-}
+ VideoEncoderConfig* encoder_config) {}
-void BaseTest::OnStreamsCreated(
+void BaseTest::OnVideoStreamsCreated(
VideoSendStream* send_stream,
- const std::vector<VideoReceiveStream*>& receive_streams) {
-}
+ const std::vector<VideoReceiveStream*>& receive_streams) {}
void BaseTest::OnFrameGeneratorCapturerCreated(
FrameGeneratorCapturer* frame_generator_capturer) {
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index 7828986..32820ed 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -67,14 +67,14 @@
rtc::scoped_ptr<Call> sender_call_;
rtc::scoped_ptr<PacketTransport> send_transport_;
- VideoSendStream::Config send_config_;
- VideoEncoderConfig encoder_config_;
- VideoSendStream* send_stream_;
+ VideoSendStream::Config video_send_config_;
+ VideoEncoderConfig video_encoder_config_;
+ VideoSendStream* video_send_stream_;
rtc::scoped_ptr<Call> receiver_call_;
rtc::scoped_ptr<PacketTransport> receive_transport_;
- std::vector<VideoReceiveStream::Config> receive_configs_;
- std::vector<VideoReceiveStream*> receive_streams_;
+ std::vector<VideoReceiveStream::Config> video_receive_configs_;
+ std::vector<VideoReceiveStream*> video_receive_streams_;
rtc::scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
test::FakeEncoder fake_encoder_;
@@ -97,11 +97,11 @@
virtual void OnTransportsCreated(PacketTransport* send_transport,
PacketTransport* receive_transport);
- virtual void ModifyConfigs(
+ virtual void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config);
- virtual void OnStreamsCreated(
+ virtual void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams);
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index bd9c198..659af2f 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -54,8 +54,8 @@
EndToEndTest() {}
virtual ~EndToEndTest() {
- EXPECT_EQ(nullptr, send_stream_);
- EXPECT_TRUE(receive_streams_.empty());
+ EXPECT_EQ(nullptr, video_send_stream_);
+ EXPECT_TRUE(video_receive_streams_.empty());
}
protected:
@@ -92,8 +92,8 @@
CreateStreams();
- receive_streams_[0]->Start();
- receive_streams_[0]->Start();
+ video_receive_streams_[0]->Start();
+ video_receive_streams_[0]->Start();
DestroyStreams();
}
@@ -107,8 +107,8 @@
CreateStreams();
- receive_streams_[0]->Stop();
- receive_streams_[0]->Stop();
+ video_receive_streams_[0]->Stop();
+ video_receive_streams_[0]->Stop();
DestroyStreams();
}
@@ -163,8 +163,8 @@
CreateMatchingReceiveConfigs(&receiver_transport);
TestFrameCallback pre_render_callback;
- receive_configs_[0].pre_render_callback = &pre_render_callback;
- receive_configs_[0].renderer = &renderer;
+ video_receive_configs_[0].pre_render_callback = &pre_render_callback;
+ video_receive_configs_[0].renderer = &renderer;
CreateStreams();
Start();
@@ -173,7 +173,8 @@
// check that the callbacks are done after processing video.
rtc::scoped_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(kWidth, kHeight));
- send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
+ video_send_stream_->Input()->IncomingCapturedFrame(
+ *frame_generator->NextFrame());
EXPECT_TRUE(pre_render_callback.Wait())
<< "Timed out while waiting for pre-render callback.";
EXPECT_TRUE(renderer.Wait())
@@ -212,15 +213,17 @@
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
- receive_configs_[0].renderer = &renderer;
+ video_receive_configs_[0].renderer = &renderer;
CreateStreams();
Start();
rtc::scoped_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(
- encoder_config_.streams[0].width, encoder_config_.streams[0].height));
- send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
+ video_encoder_config_.streams[0].width,
+ video_encoder_config_.streams[0].height));
+ video_send_stream_->Input()->IncomingCapturedFrame(
+ *frame_generator->NextFrame());
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
@@ -247,9 +250,10 @@
<< "Timed out while waiting for enough frames to be decoded.";
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = encoder_.get();
send_config->encoder_settings.payload_name = "VP9";
send_config->encoder_settings.payload_type = 124;
@@ -297,9 +301,10 @@
<< "Timed out while waiting for enough frames to be decoded.";
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms =
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->encoder_settings.encoder = &fake_encoder_;
@@ -429,9 +434,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
}
@@ -525,9 +531,10 @@
kDropNextMediaPacket,
} state_;
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
// TODO(pbos): Run this test with combined NACK/FEC enabled as well.
// int rtp_history_ms = 1000;
// (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
@@ -641,9 +648,10 @@
return config;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
// Configure hybrid NACK/FEC.
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->rtp.fec.red_payload_type = kRedPayloadType;
@@ -740,9 +748,10 @@
}
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].pre_render_callback = this;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -871,16 +880,16 @@
CreateSendConfig(1, &sender_transport);
rtc::scoped_ptr<VideoEncoder> encoder(
VideoEncoder::Create(VideoEncoder::kVp8));
- send_config_.encoder_settings.encoder = encoder.get();
- send_config_.encoder_settings.payload_name = "VP8";
- ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
- encoder_config_.streams[0].width = kWidth;
- encoder_config_.streams[0].height = kHeight;
- send_config_.pre_encode_callback = &pre_encode_callback;
+ video_send_config_.encoder_settings.encoder = encoder.get();
+ video_send_config_.encoder_settings.payload_name = "VP8";
+ ASSERT_EQ(1u, video_encoder_config_.streams.size()) << "Test setup error.";
+ video_encoder_config_.streams[0].width = kWidth;
+ video_encoder_config_.streams[0].height = kHeight;
+ video_send_config_.pre_encode_callback = &pre_encode_callback;
CreateMatchingReceiveConfigs(&receiver_transport);
- receive_configs_[0].pre_render_callback = &pre_render_callback;
- receive_configs_[0].renderer = &renderer;
+ video_receive_configs_[0].pre_render_callback = &pre_render_callback;
+ video_receive_configs_[0].renderer = &renderer;
CreateStreams();
Start();
@@ -889,7 +898,8 @@
// check that the callbacks are done after processing video.
rtc::scoped_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(kWidth / 2, kHeight / 2));
- send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
+ video_send_stream_->Input()->IncomingCapturedFrame(
+ *frame_generator->NextFrame());
EXPECT_TRUE(pre_encode_callback.Wait())
<< "Timed out while waiting for pre-encode callback.";
@@ -970,9 +980,10 @@
bool IsTextureSupported() const override { return false; }
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
(*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
(*receive_configs)[0].renderer = this;
@@ -1047,8 +1058,8 @@
CreateFrameGeneratorCapturer();
Start();
- receiver_call_->DestroyVideoReceiveStream(receive_streams_[0]);
- receive_streams_.clear();
+ receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
+ video_receive_streams_.clear();
// Wait() waits for a received packet.
EXPECT_TRUE(input_observer.Wait());
@@ -1119,9 +1130,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
@@ -1650,16 +1662,18 @@
CreateSendConfig(1, &sender_transport);
CreateMatchingReceiveConfigs(&receiver_transport);
- send_config_.post_encode_callback = &post_encode_observer;
- receive_configs_[0].pre_decode_callback = &pre_decode_observer;
+ video_send_config_.post_encode_callback = &post_encode_observer;
+ video_receive_configs_[0].pre_decode_callback = &pre_decode_observer;
CreateStreams();
Start();
rtc::scoped_ptr<test::FrameGenerator> frame_generator(
test::FrameGenerator::CreateChromaGenerator(
- encoder_config_.streams[0].width, encoder_config_.streams[0].height));
- send_stream_->Input()->IncomingCapturedFrame(*frame_generator->NextFrame());
+ video_encoder_config_.streams[0].width,
+ video_encoder_config_.streams[0].height));
+ video_send_stream_->Input()->IncomingCapturedFrame(
+ *frame_generator->NextFrame());
EXPECT_TRUE(post_encode_observer.Wait())
<< "Timed out while waiting for send-side encoded-frame callback.";
@@ -1812,7 +1826,8 @@
receive_stream_nack_packets +=
stats.rtcp_packet_type_counts.nack_packets;
}
- if (send_stream_nack_packets >= 1 && receive_stream_nack_packets >= 1) {
+ if (send_stream_nack_packets >= 1 &&
+ receive_stream_nack_packets >= 1) {
// NACK packet sent on receive stream and received on sent stream.
if (MinMetricRunTimePassed())
observation_complete_.Set();
@@ -1829,14 +1844,15 @@
return elapsed_sec > metrics::kMinRunTimeInSeconds;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@@ -1907,9 +1923,10 @@
return elapsed_sec > metrics::kMinRunTimeInSeconds * 2;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
// NACK
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -2002,17 +2019,17 @@
EXPECT_EQ(1,
test::NumHistogramSamples("WebRTC.Video.ReceivedHeightInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].width),
test::LastHistogramSample(video_prefix + "InputWidthInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].height),
test::LastHistogramSample(video_prefix + "InputHeightInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].width),
test::LastHistogramSample(video_prefix + "SentWidthInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].height),
test::LastHistogramSample(video_prefix + "SentHeightInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].width),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].width),
test::LastHistogramSample("WebRTC.Video.ReceivedWidthInPixels"));
- EXPECT_EQ(static_cast<int>(encoder_config_.streams[0].height),
+ EXPECT_EQ(static_cast<int>(video_encoder_config_.streams[0].height),
test::LastHistogramSample("WebRTC.Video.ReceivedHeightInPixels"));
EXPECT_EQ(1,
@@ -2152,9 +2169,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].rtp.rtcp_mode = RtcpMode::kReducedSize;
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
enable_rrtr_;
@@ -2221,9 +2239,10 @@
size_t GetNumStreams() const override { return num_ssrcs_; }
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
if (num_ssrcs_ > 1) {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
@@ -2233,12 +2252,12 @@
}
}
- encoder_config_all_streams_ = *encoder_config;
+ video_encoder_config_all_streams_ = *encoder_config;
if (send_single_ssrc_first_)
encoder_config->streams.resize(1);
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@@ -2251,7 +2270,8 @@
if (send_single_ssrc_first_) {
// Set full simulcast and continue with the rest of the SSRCs.
- send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
+ send_stream_->ReconfigureVideoEncoder(
+ video_encoder_config_all_streams_);
EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
}
}
@@ -2267,7 +2287,7 @@
bool expect_single_ssrc_;
VideoSendStream* send_stream_;
- VideoEncoderConfig encoder_config_all_streams_;
+ VideoEncoderConfig video_encoder_config_all_streams_;
} test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
RunBaseTest(&test, FakeNetworkPipe::Config());
@@ -2283,15 +2303,16 @@
send_stream_(nullptr),
bitrate_kbps_(0) {}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
}
@@ -2516,9 +2537,10 @@
return config;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->pre_encode_callback = this; // Used to inject delay.
expected_cname_ = send_config->rtp.c_name = "SomeCName";
@@ -2533,7 +2555,7 @@
size_t GetNumStreams() const override { return kNumSsrcs; }
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@@ -2618,7 +2640,7 @@
sent_rtp_(0) {}
private:
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
receive_stream_ = receive_streams[0];
@@ -2694,9 +2716,10 @@
size_t GetNumStreams() const override { return kNumSsrcs; }
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
encoder_config->streams[i].min_bitrate_bps = 10000;
@@ -2834,29 +2857,29 @@
if (use_rtx) {
for (size_t i = 0; i < kNumSsrcs; ++i) {
- send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+ video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
}
- send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
+ video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
}
// Lower bitrates so that all streams send initially.
- for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
- encoder_config_.streams[i].min_bitrate_bps = 10000;
- encoder_config_.streams[i].target_bitrate_bps = 15000;
- encoder_config_.streams[i].max_bitrate_bps = 20000;
+ for (size_t i = 0; i < video_encoder_config_.streams.size(); ++i) {
+ video_encoder_config_.streams[i].min_bitrate_bps = 10000;
+ video_encoder_config_.streams[i].target_bitrate_bps = 15000;
+ video_encoder_config_.streams[i].max_bitrate_bps = 20000;
}
// Use the same total bitrates when sending a single stream to avoid lowering
// the bitrate estimate and requiring a subsequent rampup.
- VideoEncoderConfig one_stream = encoder_config_;
+ VideoEncoderConfig one_stream = video_encoder_config_;
one_stream.streams.resize(1);
- for (size_t i = 1; i < encoder_config_.streams.size(); ++i) {
+ for (size_t i = 1; i < video_encoder_config_.streams.size(); ++i) {
one_stream.streams.front().min_bitrate_bps +=
- encoder_config_.streams[i].min_bitrate_bps;
+ video_encoder_config_.streams[i].min_bitrate_bps;
one_stream.streams.front().target_bitrate_bps +=
- encoder_config_.streams[i].target_bitrate_bps;
+ video_encoder_config_.streams[i].target_bitrate_bps;
one_stream.streams.front().max_bitrate_bps +=
- encoder_config_.streams[i].max_bitrate_bps;
+ video_encoder_config_.streams[i].max_bitrate_bps;
}
CreateMatchingReceiveConfigs(&receive_transport);
@@ -2872,12 +2895,12 @@
// get set once (this could be due to using std::map::insert for instance).
for (size_t i = 0; i < 3; ++i) {
frame_generator_capturer_->Stop();
- sender_call_->DestroyVideoSendStream(send_stream_);
+ sender_call_->DestroyVideoSendStream(video_send_stream_);
// Re-create VideoSendStream with only one stream.
- send_stream_ =
- sender_call_->CreateVideoSendStream(send_config_, one_stream);
- send_stream_->Start();
+ video_send_stream_ =
+ sender_call_->CreateVideoSendStream(video_send_config_, one_stream);
+ video_send_stream_->Start();
CreateFrameGeneratorCapturer();
frame_generator_capturer_->Start();
@@ -2885,18 +2908,18 @@
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams.
- send_stream_->ReconfigureVideoEncoder(encoder_config_);
+ video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
observer.ResetExpectedSsrcs(kNumSsrcs);
EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
// Reconfigure down to one stream.
- send_stream_->ReconfigureVideoEncoder(one_stream);
+ video_send_stream_->ReconfigureVideoEncoder(one_stream);
observer.ResetExpectedSsrcs(1);
EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams.
- send_stream_->ReconfigureVideoEncoder(encoder_config_);
+ video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
observer.ResetExpectedSsrcs(kNumSsrcs);
EXPECT_TRUE(observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
@@ -2973,9 +2996,10 @@
receiver_call_ = receiver_call;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
}
@@ -3149,7 +3173,7 @@
UnusedTransport transport;
CreateSendConfig(1, &transport);
UnusedEncoder unused_encoder;
- send_config_.encoder_settings.encoder = &unused_encoder;
+ video_send_config_.encoder_settings.encoder = &unused_encoder;
CreateStreams();
CreateFrameGeneratorCapturer();
diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc
index a94cb46..d09d2a2 100644
--- a/webrtc/video/video_quality_test.cc
+++ b/webrtc/video/video_quality_test.cc
@@ -794,36 +794,38 @@
RTC_NOTREACHED() << "Codec not supported!";
return;
}
- send_config_.encoder_settings.encoder = encoder_.get();
- send_config_.encoder_settings.payload_name = params_.common.codec;
- send_config_.encoder_settings.payload_type = payload_type;
- send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
+ video_send_config_.encoder_settings.encoder = encoder_.get();
+ video_send_config_.encoder_settings.payload_name = params_.common.codec;
+ video_send_config_.encoder_settings.payload_type = payload_type;
+ video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
for (size_t i = 0; i < num_streams; ++i)
- send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
+ video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
- send_config_.rtp.extensions.clear();
+ video_send_config_.rtp.extensions.clear();
if (params_.common.send_side_bwe) {
- send_config_.rtp.extensions.push_back(
+ video_send_config_.rtp.extensions.push_back(
RtpExtension(RtpExtension::kTransportSequenceNumber,
test::kTransportSequenceNumberExtensionId));
} else {
- send_config_.rtp.extensions.push_back(RtpExtension(
+ video_send_config_.rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
}
- encoder_config_.min_transmit_bitrate_bps = params_.common.min_transmit_bps;
- encoder_config_.streams = params_.ss.streams;
- encoder_config_.spatial_layers = params_.ss.spatial_layers;
+ video_encoder_config_.min_transmit_bitrate_bps =
+ params_.common.min_transmit_bps;
+ video_encoder_config_.streams = params_.ss.streams;
+ video_encoder_config_.spatial_layers = params_.ss.spatial_layers;
CreateMatchingReceiveConfigs(recv_transport);
for (size_t i = 0; i < num_streams; ++i) {
- receive_configs_[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
- receive_configs_[i].rtp.rtx[kSendRtxPayloadType].ssrc = kSendRtxSsrcs[i];
- receive_configs_[i].rtp.rtx[kSendRtxPayloadType].payload_type =
+ video_receive_configs_[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
+ video_receive_configs_[i].rtp.rtx[kSendRtxPayloadType].ssrc =
+ kSendRtxSsrcs[i];
+ video_receive_configs_[i].rtp.rtx[kSendRtxPayloadType].payload_type =
kSendRtxPayloadType;
- receive_configs_[i].rtp.transport_cc = params_.common.send_side_bwe;
+ video_receive_configs_[i].rtp.transport_cc = params_.common.send_side_bwe;
}
}
@@ -831,21 +833,21 @@
RTC_CHECK(params_.screenshare.enabled);
// Fill out codec settings.
- encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
+ video_encoder_config_.content_type = VideoEncoderConfig::ContentType::kScreen;
if (params_.common.codec == "VP8") {
codec_settings_.VP8 = VideoEncoder::GetDefaultVp8Settings();
codec_settings_.VP8.denoisingOn = false;
codec_settings_.VP8.frameDroppingOn = false;
codec_settings_.VP8.numberOfTemporalLayers =
static_cast<unsigned char>(params_.common.num_temporal_layers);
- encoder_config_.encoder_specific_settings = &codec_settings_.VP8;
+ video_encoder_config_.encoder_specific_settings = &codec_settings_.VP8;
} else if (params_.common.codec == "VP9") {
codec_settings_.VP9 = VideoEncoder::GetDefaultVp9Settings();
codec_settings_.VP9.denoisingOn = false;
codec_settings_.VP9.frameDroppingOn = false;
codec_settings_.VP9.numberOfTemporalLayers =
static_cast<unsigned char>(params_.common.num_temporal_layers);
- encoder_config_.encoder_specific_settings = &codec_settings_.VP9;
+ video_encoder_config_.encoder_specific_settings = &codec_settings_.VP9;
codec_settings_.VP9.numberOfSpatialLayers =
static_cast<unsigned char>(params_.ss.num_spatial_layers);
}
@@ -969,23 +971,23 @@
recv_transport.SetReceiver(sender_call_->Receiver());
SetupCommon(&analyzer, &recv_transport);
- send_config_.encoding_time_observer = &analyzer;
- receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
- for (auto& config : receive_configs_)
+ video_send_config_.encoding_time_observer = &analyzer;
+ video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
+ for (auto& config : video_receive_configs_)
config.pre_decode_callback = &analyzer;
if (params_.screenshare.enabled)
SetupScreenshare();
CreateStreams();
- analyzer.input_ = send_stream_->Input();
- analyzer.send_stream_ = send_stream_;
+ analyzer.input_ = video_send_stream_->Input();
+ analyzer.send_stream_ = video_send_stream_;
CreateCapturer(&analyzer);
- send_stream_->Start();
- for (size_t i = 0; i < receive_streams_.size(); ++i)
- receive_streams_[i]->Start();
+ video_send_stream_->Start();
+ for (VideoReceiveStream* receive_stream : video_receive_streams_)
+ receive_stream->Start();
capturer_->Start();
analyzer.Wait();
@@ -994,9 +996,9 @@
recv_transport.StopSending();
capturer_->Stop();
- for (size_t i = 0; i < receive_streams_.size(); ++i)
- receive_streams_[i]->Stop();
- send_stream_->Stop();
+ for (VideoReceiveStream* receive_stream : video_receive_streams_)
+ receive_stream->Stop();
+ video_send_stream_->Stop();
DestroyStreams();
@@ -1040,29 +1042,30 @@
SetupCommon(&transport, &transport);
- send_config_.local_renderer = local_preview.get();
- receive_configs_[stream_id].renderer = loopback_video.get();
+ video_send_config_.local_renderer = local_preview.get();
+ video_receive_configs_[stream_id].renderer = loopback_video.get();
if (params_.screenshare.enabled)
SetupScreenshare();
- send_stream_ = call->CreateVideoSendStream(send_config_, encoder_config_);
+ video_send_stream_ =
+ call->CreateVideoSendStream(video_send_config_, video_encoder_config_);
VideoReceiveStream* receive_stream =
- call->CreateVideoReceiveStream(receive_configs_[stream_id]);
- CreateCapturer(send_stream_->Input());
+ call->CreateVideoReceiveStream(video_receive_configs_[stream_id]);
+ CreateCapturer(video_send_stream_->Input());
receive_stream->Start();
- send_stream_->Start();
+ video_send_stream_->Start();
capturer_->Start();
test::PressEnterToContinue();
capturer_->Stop();
- send_stream_->Stop();
+ video_send_stream_->Stop();
receive_stream->Stop();
call->DestroyVideoReceiveStream(receive_stream);
- call->DestroyVideoSendStream(send_stream_);
+ call->DestroyVideoSendStream(video_send_stream_);
transport.StopSending();
}
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 3f14af2..f48f7b7 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -70,8 +70,8 @@
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateStreams();
- send_stream_->Start();
- send_stream_->Start();
+ video_send_stream_->Start();
+ video_send_stream_->Start();
DestroyStreams();
}
@@ -82,8 +82,8 @@
test::NullTransport transport;
CreateSendConfig(1, &transport);
CreateStreams();
- send_stream_->Stop();
- send_stream_->Stop();
+ video_send_stream_->Stop();
+ video_send_stream_->Stop();
DestroyStreams();
}
@@ -111,9 +111,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.c_name = kCName;
}
@@ -146,9 +147,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
RtpExtension::kAbsSendTime, test::kAbsSendTimeExtensionId));
@@ -187,9 +189,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = &encoder_;
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@@ -230,9 +233,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = &encoder_;
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@@ -383,9 +387,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
@@ -482,9 +487,10 @@
return SEND_PACKET;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
@@ -666,9 +672,10 @@
return config;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
@@ -820,15 +827,16 @@
high_remb_bps_ = value;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
transport_adapter_->Enable();
@@ -1010,7 +1018,7 @@
return DROP_PACKET;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
@@ -1021,9 +1029,10 @@
rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
feedback_transport_.reset(
new internal::TransportAdapter(send_config->send_transport));
feedback_transport_->Enable();
@@ -1080,20 +1089,20 @@
Call::Config::BitrateConfig bitrate_config;
bitrate_config.start_bitrate_bps =
- 2 * encoder_config_.streams[0].max_bitrate_bps;
+ 2 * video_encoder_config_.streams[0].max_bitrate_bps;
sender_call_->SetBitrateConfig(bitrate_config);
StartBitrateObserver encoder;
- send_config_.encoder_settings.encoder = &encoder;
+ video_send_config_.encoder_settings.encoder = &encoder;
CreateStreams();
- EXPECT_EQ(encoder_config_.streams[0].max_bitrate_bps / 1000,
+ EXPECT_EQ(video_encoder_config_.streams[0].max_bitrate_bps / 1000,
encoder.GetStartBitrateKbps());
- encoder_config_.streams[0].max_bitrate_bps =
+ video_encoder_config_.streams[0].max_bitrate_bps =
2 * bitrate_config.start_bitrate_bps;
- send_stream_->ReconfigureVideoEncoder(encoder_config_);
+ video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_);
// New bitrate should be reconfigured above the previous max. As there's no
// network connection this shouldn't be flaky, as no bitrate should've been
@@ -1138,14 +1147,14 @@
test::NullTransport transport;
CreateSendConfig(1, &transport);
FrameObserver observer;
- send_config_.pre_encode_callback = &observer;
+ video_send_config_.pre_encode_callback = &observer;
CreateStreams();
// Prepare five input frames. Send ordinary VideoFrame and texture frames
// alternatively.
std::vector<VideoFrame> input_frames;
- int width = static_cast<int>(encoder_config_.streams[0].width);
- int height = static_cast<int>(encoder_config_.streams[0].height);
+ int width = static_cast<int>(video_encoder_config_.streams[0].width);
+ int height = static_cast<int>(video_encoder_config_.streams[0].height);
test::FakeNativeHandle* handle1 = new test::FakeNativeHandle();
test::FakeNativeHandle* handle2 = new test::FakeNativeHandle();
test::FakeNativeHandle* handle3 = new test::FakeNativeHandle();
@@ -1158,17 +1167,17 @@
input_frames.push_back(test::CreateFakeNativeHandleFrame(
handle3, width, height, 5, 5, kVideoRotation_0));
- send_stream_->Start();
+ video_send_stream_->Start();
for (size_t i = 0; i < input_frames.size(); i++) {
- send_stream_->Input()->IncomingCapturedFrame(input_frames[i]);
+ video_send_stream_->Input()->IncomingCapturedFrame(input_frames[i]);
// Do not send the next frame too fast, so the frame dropper won't drop it.
if (i < input_frames.size() - 1)
- SleepMs(1000 / encoder_config_.streams[0].max_framerate);
+ SleepMs(1000 / video_encoder_config_.streams[0].max_framerate);
// Wait until the output frame is received before sending the next input
// frame. Or the previous input frame may be replaced without delivering.
observer.WaitOutputFrame();
}
- send_stream_->Stop();
+ video_send_stream_->Stop();
// Test if the input and output frames are the same. render_time_ms and
// timestamp are not compared because capturer sets those values.
@@ -1310,7 +1319,7 @@
return 0;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
// Encoder initialization should be done in stream construction before
@@ -1319,9 +1328,10 @@
stream_ = send_stream;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
encoder_config_ = *encoder_config;
}
@@ -1365,14 +1375,15 @@
num_initializations_(0) {}
private:
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
encoder_config_ = *encoder_config;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
@@ -1426,9 +1437,10 @@
}
private:
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
send_config->encoder_settings.payload_name = codec_name_;
@@ -1441,7 +1453,7 @@
encoder_config_ = *encoder_config;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
@@ -1618,9 +1630,10 @@
return test::FakeEncoder::InitEncode(
config, number_of_cores, max_payload_size);
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
EXPECT_EQ(1u, encoder_config->streams.size());
EXPECT_TRUE(
@@ -1694,9 +1707,10 @@
return config;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
// Set bitrates lower/higher than min/max to make sure they are properly
// capped.
@@ -1709,7 +1723,7 @@
call_ = sender_call;
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@@ -1786,9 +1800,10 @@
observation_complete_.Set();
return 0;
}
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder = this;
EXPECT_EQ(kNumStreams, encoder_config->streams.size());
}
@@ -1812,7 +1827,7 @@
}
}
- void OnStreamsCreated(
+ void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@@ -1833,7 +1848,7 @@
packets_sent_(0),
frames_sent_(0) {}
- virtual void ModifyConfigsHook(
+ virtual void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) {}
@@ -1843,14 +1858,15 @@
private:
const int kVp9PayloadType = 105;
- void ModifyConfigs(VideoSendStream::Config* send_config,
- std::vector<VideoReceiveStream::Config>* receive_configs,
- VideoEncoderConfig* encoder_config) override {
+ void ModifyVideoConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) override {
encoder_config->encoder_specific_settings = &vp9_settings_;
send_config->encoder_settings.encoder = vp9_encoder_.get();
send_config->encoder_settings.payload_name = "VP9";
send_config->encoder_settings.payload_type = kVp9PayloadType;
- ModifyConfigsHook(send_config, receive_configs, encoder_config);
+ ModifyVideoConfigsHook(send_config, receive_configs, encoder_config);
EXPECT_EQ(1u, encoder_config->streams.size());
encoder_config->streams[0].temporal_layer_thresholds_bps.resize(
vp9_settings_.numberOfTemporalLayers - 1);
@@ -2141,7 +2157,7 @@
: num_temporal_layers_(num_temporal_layers),
num_spatial_layers_(num_spatial_layers),
l_field_(num_temporal_layers > 1 || num_spatial_layers > 1) {}
- void ModifyConfigsHook(
+ void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
@@ -2181,7 +2197,7 @@
TEST_F(VideoSendStreamTest, Vp9FlexModeRefCount) {
class FlexibleMode : public Vp9HeaderObserver {
- void ModifyConfigsHook(
+ void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
diff --git a/webrtc/webrtc_tests.gypi b/webrtc/webrtc_tests.gypi
index 31d23ba..e0bf276 100644
--- a/webrtc/webrtc_tests.gypi
+++ b/webrtc/webrtc_tests.gypi
@@ -219,12 +219,12 @@
'type': '<(gtest_target_type)',
'sources': [
'call/call_perf_tests.cc',
+ 'call/rampup_tests.cc',
+ 'call/rampup_tests.h',
'modules/audio_coding/neteq/test/neteq_performance_unittest.cc',
'modules/audio_processing/audio_processing_performance_unittest.cc',
'modules/remote_bitrate_estimator/remote_bitrate_estimators_test.cc',
'video/full_stack.cc',
- 'video/rampup_tests.cc',
- 'video/rampup_tests.h',
],
'dependencies': [
'<(DEPTH)/testing/gmock.gyp:gmock',
