summaryrefslogtreecommitdiff
path: root/video/rampup_tests.cc
diff options
context:
space:
mode:
Diffstat (limited to 'video/rampup_tests.cc')
-rw-r--r--video/rampup_tests.cc125
1 files changed, 74 insertions, 51 deletions
diff --git a/video/rampup_tests.cc b/video/rampup_tests.cc
index c86963d0..94f1c19d 100644
--- a/video/rampup_tests.cc
+++ b/video/rampup_tests.cc
@@ -38,8 +38,9 @@
namespace webrtc {
namespace {
-static const int kAbsoluteSendTimeExtensionId = 7;
+static const int kTransmissionTimeOffsetExtensionId = 6;
static const int kMaxPacketSize = 1500;
+static const unsigned int kSingleStreamTargetBps = 1000000;
class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
public:
@@ -57,6 +58,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))),
crit_(CriticalSectionWrapper::CreateCriticalSection()),
expected_bitrate_bps_(0),
+ start_bitrate_bps_(0),
rtx_media_ssrcs_(rtx_media_ssrcs),
total_sent_(0),
padding_sent_(0),
@@ -75,8 +77,8 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
- rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
- kAbsoluteSendTimeExtensionId);
+ rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+ kTransmissionTimeOffsetExtensionId);
AbsoluteSendTimeRemoteBitrateEstimatorFactory rbe_factory;
const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
remote_bitrate_estimator_.reset(
@@ -89,10 +91,25 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
expected_bitrate_bps_ = expected_bitrate_bps;
}
+ void set_start_bitrate_bps(unsigned int start_bitrate_bps) {
+ CriticalSectionScoped lock(crit_.get());
+ start_bitrate_bps_ = start_bitrate_bps;
+ }
+
virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
unsigned int bitrate) OVERRIDE {
CriticalSectionScoped lock(crit_.get());
assert(expected_bitrate_bps_ > 0);
+ if (start_bitrate_bps_ != 0) {
+ // For tests with an explicitly set start bitrate, verify the first
+ // bitrate estimate is close to the start bitrate and lower than the
+ // test target bitrate. This is to verify a call respects the configured
+ // start bitrate, but due to the BWE implementation we can't guarantee the
+ // first estimate really is as high as the start bitrate.
+ EXPECT_GT(bitrate, 0.9 * start_bitrate_bps_);
+ EXPECT_LT(bitrate, expected_bitrate_bps_);
+ start_bitrate_bps_ = 0;
+ }
if (bitrate >= expected_bitrate_bps_) {
// Just trigger if there was any rtx padding packet.
if (rtx_media_ssrcs_.empty() || rtx_media_sent_ > 0) {
@@ -178,6 +195,7 @@ class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
const scoped_ptr<CriticalSectionWrapper> crit_;
unsigned int expected_bitrate_bps_ GUARDED_BY(crit_);
+ unsigned int start_bitrate_bps_ GUARDED_BY(crit_);
SsrcMap rtx_media_ssrcs_ GUARDED_BY(crit_);
size_t total_sent_ GUARDED_BY(crit_);
size_t padding_sent_ GUARDED_BY(crit_);
@@ -218,8 +236,8 @@ class LowRateStreamObserver : public test::DirectTransport,
rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
rtp_rtcp_->SetREMBStatus(true);
rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
- rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
- kAbsoluteSendTimeExtensionId);
+ rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
+ kTransmissionTimeOffsetExtensionId);
AbsoluteSendTimeRemoteBitrateEstimatorFactory rbe_factory;
const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 10000;
remote_bitrate_estimator_.reset(
@@ -400,14 +418,16 @@ class LowRateStreamObserver : public test::DirectTransport,
size_t total_overuse_bytes_ GUARDED_BY(crit_);
bool suspended_in_stats_ GUARDED_BY(crit_);
};
-}
+} // namespace
class RampUpTest : public ::testing::Test {
public:
virtual void SetUp() { reserved_ssrcs_.clear(); }
protected:
- void RunRampUpTest(bool pacing, bool rtx, size_t num_streams) {
+ void RunRampUpTest(bool rtx,
+ size_t num_streams,
+ unsigned int start_bitrate_bps) {
std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100));
std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200));
StreamObserver::SsrcMap rtx_ssrc_map;
@@ -421,59 +441,61 @@ class RampUpTest : public ::testing::Test {
Clock::GetRealTimeClock());
Call::Config call_config(&stream_observer);
- webrtc::Config webrtc_config;
- call_config.webrtc_config = &webrtc_config;
- webrtc_config.Set<PaddingStrategy>(new PaddingStrategy(rtx));
+ if (start_bitrate_bps != 0) {
+ call_config.start_bitrate_bps = start_bitrate_bps;
+ stream_observer.set_start_bitrate_bps(start_bitrate_bps);
+ }
scoped_ptr<Call> call(Call::Create(call_config));
VideoSendStream::Config send_config = call->GetDefaultSendConfig();
receiver_transport.SetReceiver(call->Receiver());
test::FakeEncoder encoder(Clock::GetRealTimeClock());
- send_config.encoder_settings =
- test::CreateEncoderSettings(&encoder, "FAKE", 125, num_streams);
+ send_config.encoder_settings.encoder = &encoder;
+ send_config.encoder_settings.payload_type = 125;
+ send_config.encoder_settings.payload_name = "FAKE";
+ std::vector<VideoStream> video_streams =
+ test::CreateVideoStreams(num_streams);
if (num_streams == 1) {
- send_config.encoder_settings.streams[0].target_bitrate_bps = 2000000;
- send_config.encoder_settings.streams[0].max_bitrate_bps = 2000000;
+ video_streams[0].target_bitrate_bps = 2000000;
+ video_streams[0].max_bitrate_bps = 2000000;
}
- send_config.pacing = pacing;
send_config.rtp.nack.rtp_history_ms = 1000;
send_config.rtp.ssrcs = ssrcs;
if (rtx) {
send_config.rtp.rtx.payload_type = 96;
send_config.rtp.rtx.ssrcs = rtx_ssrcs;
+ send_config.rtp.rtx.pad_with_redundant_payloads = true;
}
send_config.rtp.extensions.push_back(
- RtpExtension(RtpExtension::kAbsSendTime, kAbsoluteSendTimeExtensionId));
+ RtpExtension(RtpExtension::kTOffset,
+ kTransmissionTimeOffsetExtensionId));
if (num_streams == 1) {
// For single stream rampup until 1mbps
- stream_observer.set_expected_bitrate_bps(1000000);
+ stream_observer.set_expected_bitrate_bps(kSingleStreamTargetBps);
} else {
// For multi stream rampup until all streams are being sent. That means
- // enough birate to sent all the target streams plus the min bitrate of
+ // enough birate to send all the target streams plus the min bitrate of
// the last one.
- int expected_bitrate_bps =
- send_config.encoder_settings.streams.back().min_bitrate_bps;
- for (size_t i = 0; i < send_config.encoder_settings.streams.size() - 1;
- ++i) {
- expected_bitrate_bps +=
- send_config.encoder_settings.streams[i].target_bitrate_bps;
+ int expected_bitrate_bps = video_streams.back().min_bitrate_bps;
+ for (size_t i = 0; i < video_streams.size() - 1; ++i) {
+ expected_bitrate_bps += video_streams[i].target_bitrate_bps;
}
stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
}
- VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+ VideoSendStream* send_stream =
+ call->CreateVideoSendStream(send_config, video_streams, NULL);
scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
- test::FrameGeneratorCapturer::Create(
- send_stream->Input(),
- send_config.encoder_settings.streams.back().width,
- send_config.encoder_settings.streams.back().height,
- send_config.encoder_settings.streams.back().max_framerate,
- Clock::GetRealTimeClock()));
+ test::FrameGeneratorCapturer::Create(send_stream->Input(),
+ video_streams.back().width,
+ video_streams.back().height,
+ video_streams.back().max_framerate,
+ Clock::GetRealTimeClock()));
send_stream->Start();
frame_generator_capturer->Start();
@@ -504,23 +526,29 @@ class RampUpTest : public ::testing::Test {
receiver_transport.SetReceiver(call->Receiver());
test::FakeEncoder encoder(Clock::GetRealTimeClock());
- send_config.encoder_settings =
- test::CreateEncoderSettings(&encoder, "FAKE", 125, number_of_streams);
+ send_config.encoder_settings.encoder = &encoder;
+ send_config.encoder_settings.payload_type = 125;
+ send_config.encoder_settings.payload_name = "FAKE";
+ std::vector<VideoStream> video_streams =
+ test::CreateVideoStreams(number_of_streams);
+
send_config.rtp.nack.rtp_history_ms = 1000;
send_config.rtp.ssrcs.insert(
send_config.rtp.ssrcs.begin(), ssrcs.begin(), ssrcs.end());
send_config.rtp.extensions.push_back(
- RtpExtension(RtpExtension::kAbsSendTime, kAbsoluteSendTimeExtensionId));
+ RtpExtension(RtpExtension::kTOffset,
+ kTransmissionTimeOffsetExtensionId));
send_config.suspend_below_min_bitrate = true;
- VideoSendStream* send_stream = call->CreateVideoSendStream(send_config);
+ VideoSendStream* send_stream =
+ call->CreateVideoSendStream(send_config, video_streams, NULL);
stream_observer.SetSendStream(send_stream);
size_t width = 0;
size_t height = 0;
- for (size_t i = 0; i < send_config.encoder_settings.streams.size(); ++i) {
- size_t stream_width = send_config.encoder_settings.streams[i].width;
- size_t stream_height = send_config.encoder_settings.streams[i].height;
+ for (size_t i = 0; i < video_streams.size(); ++i) {
+ size_t stream_width = video_streams[i].width;
+ size_t stream_height = video_streams[i].height;
if (stream_width > width)
width = stream_width;
if (stream_height > height)
@@ -559,25 +587,20 @@ class RampUpTest : public ::testing::Test {
std::map<uint32_t, bool> reserved_ssrcs_;
};
-TEST_F(RampUpTest, SingleStreamWithoutPacing) {
- RunRampUpTest(false, false, 1);
-}
-
-TEST_F(RampUpTest, SingleStreamWithPacing) {
- RunRampUpTest(true, false, 1);
+TEST_F(RampUpTest, SingleStream) {
+ RunRampUpTest(false, 1, 0);
}
-TEST_F(RampUpTest, SimulcastWithoutPacing) {
- RunRampUpTest(false, false, 3);
+TEST_F(RampUpTest, Simulcast) {
+ RunRampUpTest(false, 3, 0);
}
-TEST_F(RampUpTest, SimulcastWithPacing) {
- RunRampUpTest(true, false, 3);
+TEST_F(RampUpTest, SimulcastWithRtx) {
+ RunRampUpTest(true, 3, 0);
}
-// TODO(pbos): Re-enable, webrtc:2992.
-TEST_F(RampUpTest, DISABLED_SimulcastWithPacingAndRtx) {
- RunRampUpTest(true, true, 3);
+TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
+ RunRampUpTest(false, 1, 0.9 * kSingleStreamTargetBps);
}
TEST_F(RampUpTest, UpDownUpOneStream) { RunRampUpDownUpTest(1, false); }
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-07 20:56:52 +0000