diff --git a/webrtc/call/bitrate_estimator_tests.cc b/webrtc/call/bitrate_estimator_tests.cc index d8c0d5e34d..e371270df6 100644 --- a/webrtc/call/bitrate_estimator_tests.cc +++ b/webrtc/call/bitrate_estimator_tests.cc @@ -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."); diff --git a/webrtc/call/call_perf_tests.cc b/webrtc/call/call_perf_tests.cc index c918f0e16a..faefc425d7 100644 --- a/webrtc/call/call_perf_tests.cc +++ b/webrtc/call/call_perf_tests.cc @@ -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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& receive_streams) override { send_stream_ = send_stream; } - void ModifyConfigs(VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& receive_streams) override { send_stream_ = send_stream; diff --git a/webrtc/call/packet_injection_tests.cc b/webrtc/call/packet_injection_tests.cc index 18ca0581d1..315fc7b8f2 100644 --- a/webrtc/call/packet_injection_tests.cc +++ b/webrtc/call/packet_injection_tests.cc @@ -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(); diff --git a/webrtc/video/rampup_tests.cc b/webrtc/call/rampup_tests.cc similarity index 79% rename from webrtc/video/rampup_tests.cc rename to webrtc/call/rampup_tests.cc index bc5daf5225..ace90f45e8 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 GenerateSsrcs(size_t num_streams, - uint32_t ssrc_offset) { +std::vector GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) { std::vector ssrcs; for (size_t i = 0; i != num_streams; ++i) ssrcs.push_back(static_cast(ssrc_offset + i)); @@ -40,7 +28,8 @@ std::vector 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& 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* 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()); } 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 81159e67bf..561ed0ddea 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 #include @@ -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 SsrcMap; Call::Config GetSenderCallConfig() override; - void OnStreamsCreated( + void OnVideoStreamsCreated( VideoSendStream* send_stream, const std::vector& 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* receive_configs, - VideoEncoderConfig* encoder_config) override; + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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 ssrcs_; - std::vector rtx_ssrcs_; + std::vector video_ssrcs_; + std::vector video_rtx_ssrcs_; + std::vector 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_ diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc index 5caae136af..bbc1224446 100644 --- a/webrtc/test/call_test.cc +++ b/webrtc/test/call_test.cc @@ -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* receive_configs, - VideoEncoderConfig* encoder_config) { -} + VideoEncoderConfig* encoder_config) {} -void BaseTest::OnStreamsCreated( +void BaseTest::OnVideoStreamsCreated( VideoSendStream* send_stream, - const std::vector& receive_streams) { -} + const std::vector& receive_streams) {} void BaseTest::OnFrameGeneratorCapturerCreated( FrameGeneratorCapturer* frame_generator_capturer) { diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h index 782898664e..32820edea6 100644 --- a/webrtc/test/call_test.h +++ b/webrtc/test/call_test.h @@ -67,14 +67,14 @@ class CallTest : public ::testing::Test { rtc::scoped_ptr sender_call_; rtc::scoped_ptr 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 receiver_call_; rtc::scoped_ptr receive_transport_; - std::vector receive_configs_; - std::vector receive_streams_; + std::vector video_receive_configs_; + std::vector video_receive_streams_; rtc::scoped_ptr 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* receive_configs, VideoEncoderConfig* encoder_config); - virtual void OnStreamsCreated( + virtual void OnVideoStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams); diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index bd9c198aaa..659af2f137 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -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 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 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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 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 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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(encoder_config_.streams[0].width), + EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), test::LastHistogramSample(video_prefix + "InputWidthInPixels")); - EXPECT_EQ(static_cast(encoder_config_.streams[0].height), + EXPECT_EQ(static_cast(video_encoder_config_.streams[0].height), test::LastHistogramSample(video_prefix + "InputHeightInPixels")); - EXPECT_EQ(static_cast(encoder_config_.streams[0].width), + EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), test::LastHistogramSample(video_prefix + "SentWidthInPixels")); - EXPECT_EQ(static_cast(encoder_config_.streams[0].height), + EXPECT_EQ(static_cast(video_encoder_config_.streams[0].height), test::LastHistogramSample(video_prefix + "SentHeightInPixels")); - EXPECT_EQ(static_cast(encoder_config_.streams[0].width), + EXPECT_EQ(static_cast(video_encoder_config_.streams[0].width), test::LastHistogramSample("WebRTC.Video.ReceivedWidthInPixels")); - EXPECT_EQ(static_cast(encoder_config_.streams[0].height), + EXPECT_EQ(static_cast(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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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& receive_streams) override { send_stream_ = send_stream; } - void ModifyConfigs(VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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(); diff --git a/webrtc/video/video_quality_test.cc b/webrtc/video/video_quality_test.cc index a94cb4642f..d09d2a2bf9 100644 --- a/webrtc/video/video_quality_test.cc +++ b/webrtc/video/video_quality_test.cc @@ -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(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(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(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(); } diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index 3f14af24db..f48f7b7847 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& receive_streams) override { stream_ = send_stream; } - void ModifyConfigs(VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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 input_frames; - int width = static_cast(encoder_config_.streams[0].width); - int height = static_cast(encoder_config_.streams[0].height); + int width = static_cast(video_encoder_config_.streams[0].width); + int height = static_cast(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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& receive_streams) override { stream_ = send_stream; @@ -1426,9 +1437,10 @@ class VideoCodecConfigObserver : public test::SendTest, } private: - void ModifyConfigs(VideoSendStream::Config* send_config, - std::vector* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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& 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* 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* receive_configs, - VideoEncoderConfig* encoder_config) override { + void ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector* 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* 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* receive_configs, VideoEncoderConfig* encoder_config) override { diff --git a/webrtc/webrtc_tests.gypi b/webrtc/webrtc_tests.gypi index 31d23ba158..e0bf276d4f 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',