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

Step 1 to prepare call_test.* for combined audio/video tests.

Browse Source 
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}
This commit is contained in:
stefan 2015-12-21 03:14:00 -08:00 committed by Commit bot
parent cce46fc108
commit ff483617a4
11 changed files with 461 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
webrtc/call/bitrate_estimator_tests.cc
View File

@ -119,17 +119,17 @@ class BitrateEstimatorTest : public test::CallTest {
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 @@ class BitrateEstimatorTest : public test::CallTest {
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 @@ class BitrateEstimatorTest : public test::CallTest {
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 @@ static const char* kSingleStreamLog =
"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, InstantiatesTOFPerDefaultForVideo) {
}
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, ImmediatelySwitchToASTForAudio) {
}
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 @@ TEST_F(BitrateEstimatorTest, SwitchesToASTForAudio) {
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, SwitchesToASTForAudio) {
}
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, SwitchesToASTForVideo) {
}
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.");

48
webrtc/call/call_perf_tests.cc
View File

@ -296,16 +296,16 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) {
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 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config,
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 @@ void CallPerfTest::TestCpuOveruse(LoadObserver::Load tested_load,
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 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
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 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
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 @@ TEST_F(CallPerfTest, KeepsHighBitrateWhenReconfiguringSender) {
encoder_config_ = *encoder_config;
}
void OnStreamsCreated(
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;

6
webrtc/call/packet_injection_tests.cc
View File

@ -42,13 +42,13 @@ void PacketInjectionTest::InjectIncorrectPacket(CodecType codec_type,
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();

147
webrtc/video/rampup_tests.cc → webrtc/call/rampup_tests.cc
View File

@ -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 @@ std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
}
} // 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 @@ RampUpTester::RampUpTester(size_t num_streams,
: 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 @@ RampUpTester::RampUpTester(size_t num_streams,
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 @@ Call::Config RampUpTester::GetSenderCallConfig() {
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 @@ void RampUpTester::OnTransportsCreated(
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 @@ void RampUpTester::ModifyConfigs(
}
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 @@ void RampUpTester::ModifyConfigs(
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 @@ void RampUpTester::ModifyConfigs(
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 @@ void RampUpTester::ReportResult(const std::string& measurement,
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 @@ void RampUpTester::TriggerTestDone() {
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 @@ void RampUpTester::TriggerTestDone() {
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 @@ RampUpDownUpTester::RampUpDownUpTester(size_t num_streams,
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 @@ Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
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 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
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 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
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 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
}
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 @@ class RampUpTest : public test::CallTest {
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, UpDownUpThreeStreamsByRedRtx) {
}
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());
}

34
webrtc/video/rampup_tests.h → webrtc/call/rampup_tests.h
View File

@ -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 int kTransportSequenceNumberExtensionId = 8;
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 @@ class RampUpTester : public test::EndToEndTest {
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 @@ class RampUpTester : public test::EndToEndTest {
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 @@ class RampUpTester : public test::EndToEndTest {
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 @@ class RampUpDownUpTester : public RampUpTester {
int sent_bytes_;
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_RAMPUP_TESTS_H_
#endif // WEBRTC_CALL_RAMPUP_TESTS_H_

101
webrtc/test/call_test.cc
View File

@ -19,10 +19,9 @@ const int kVideoRotationRtpExtensionId = 4;
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 @@ void CallTest::RunBaseTest(BaseTest* test,
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::RunBaseTest(BaseTest* test,
}
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::Start() {
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::DestroyCalls() {
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 @@ size_t BaseTest::GetNumStreams() const {
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) {

14
webrtc/test/call_test.h
View File

@ -67,14 +67,14 @@ class CallTest : public ::testing::Test {
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 @@ class BaseTest : public RtpRtcpObserver {
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);

242
webrtc/video/end_to_end_tests.cc
View File

@ -54,8 +54,8 @@ class EndToEndTest : public test::CallTest {
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 @@ TEST_F(EndToEndTest, ReceiverCanBeStartedTwice) {
CreateStreams();
receive_streams_[0]->Start();
receive_streams_[0]->Start();
video_receive_streams_[0]->Start();
video_receive_streams_[0]->Start();
DestroyStreams();
}
@ -107,8 +107,8 @@ TEST_F(EndToEndTest, ReceiverCanBeStoppedTwice) {
CreateStreams();
receive_streams_[0]->Stop();
receive_streams_[0]->Stop();
video_receive_streams_[0]->Stop();
video_receive_streams_[0]->Stop();
DestroyStreams();
}
@ -163,8 +163,8 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
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 @@ TEST_F(EndToEndTest, RendersSingleDelayedFrame) {
// 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 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
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 @@ TEST_F(EndToEndTest, SendsAndReceivesVP9) {
<< "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 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
<< "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 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
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 @@ TEST_F(EndToEndTest, CanReceiveFec) {
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 @@ TEST_F(EndToEndTest, DISABLED_ReceivedFecPacketsNotNacked) {
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 EndToEndTest::DecodesRetransmittedFrame(bool use_rtx, bool use_red) {
}
}
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 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
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 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) {
// 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 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
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 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
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 @@ void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
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 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) {
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 @@ TEST_F(EndToEndTest, VerifyNackStats) {
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 @@ TEST_F(EndToEndTest, VerifyNackStats) {
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 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx,
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 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx,
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 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
}
}
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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
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 @@ TEST_F(EndToEndTest, ReportsSetEncoderRates) {
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 @@ TEST_F(EndToEndTest, GetStats) {
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 @@ TEST_F(EndToEndTest, GetStats) {
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 @@ TEST_F(EndToEndTest, TestReceivedRtpPacketStats) {
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 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
// 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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
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 @@ TEST_F(EndToEndTest, RespectsNetworkState) {
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 @@ TEST_F(EndToEndTest, NewSendStreamsRespectNetworkDown) {
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();

79
webrtc/video/video_quality_test.cc
View File

@ -794,36 +794,38 @@ void VideoQualityTest::SetupCommon(Transport* send_transport,
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 @@ void VideoQualityTest::SetupScreenshare() {
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 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
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 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
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 @@ void VideoQualityTest::RunWithVideoRenderer(const Params& params) {
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();
}

166
webrtc/video/video_send_stream_tests.cc
View File

@ -70,8 +70,8 @@ TEST_F(VideoSendStreamTest, CanStartStartedStream) {
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_F(VideoSendStreamTest, CanStopStoppedStream) {
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 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
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 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
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 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
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 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
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 @@ class FecObserver : public test::SendTest {
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 @@ void VideoSendStreamTest::TestNackRetransmission(
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 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
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 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
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 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
return DROP_PACKET;
}
void OnStreamsCreated(
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
stream_ = send_stream;
@ -1021,9 +1029,10 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
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 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
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_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
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 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndVideoFrames) {
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 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
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 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
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 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
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 @@ class VideoCodecConfigObserver : public test::SendTest,
}
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 @@ class VideoCodecConfigObserver : public test::SendTest,
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 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
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 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
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 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
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 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
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 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
}
}
void OnStreamsCreated(
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
send_stream_ = send_stream;
@ -1833,7 +1848,7 @@ class Vp9HeaderObserver : public test::SendTest {
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 @@ class Vp9HeaderObserver : public test::SendTest {
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 @@ void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
: 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 @@ void VideoSendStreamTest::TestVp9NonFlexMode(uint8_t num_temporal_layers,
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 {

4
webrtc/webrtc_tests.gypi
View File

@ -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',