blob: 011ef6af5709f9b9118661155730428643f65926 [file] [log] [blame]
pbos@webrtc.org744fbc72013-09-10 09:26:25 +00001/*
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
pbos@webrtc.org744fbc72013-09-10 09:26:25 +000010
11#include "testing/gtest/include/gtest/gtest.h"
pbos@webrtc.org744fbc72013-09-10 09:26:25 +000012#include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
13#include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +000014#include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
pbos@webrtc.org744fbc72013-09-10 09:26:25 +000015#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
16#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
17#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +000018#include "webrtc/test/testsupport/perf_test.h"
stefan@webrtc.org3d7da882014-07-08 13:59:46 +000019#include "webrtc/video/rampup_tests.h"
pbos@webrtc.org744fbc72013-09-10 09:26:25 +000020
21namespace webrtc {
pbos@webrtc.org29023282013-09-11 10:14:56 +000022namespace {
stefan@webrtc.org3d7da882014-07-08 13:59:46 +000023
pbos@webrtc.orgc279a5d2014-01-24 09:30:53 +000024static const int kMaxPacketSize = 1500;
pbos@webrtc.org29023282013-09-11 10:14:56 +000025
stefan@webrtc.org3d7da882014-07-08 13:59:46 +000026std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
27 uint32_t ssrc_offset) {
28 std::vector<uint32_t> ssrcs;
29 for (size_t i = 0; i != num_streams; ++i)
30 ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
31 return ssrcs;
32}
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +000033} // namespace
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +000034
stefan@webrtc.org3d7da882014-07-08 13:59:46 +000035StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs,
36 newapi::Transport* feedback_transport,
37 Clock* clock,
38 RemoteBitrateEstimatorFactory* rbe_factory,
39 RateControlType control_type)
40 : clock_(clock),
41 test_done_(EventWrapper::Create()),
42 rtp_parser_(RtpHeaderParser::Create()),
43 feedback_transport_(feedback_transport),
44 receive_stats_(ReceiveStatistics::Create(clock)),
45 payload_registry_(
46 new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))),
47 crit_(CriticalSectionWrapper::CreateCriticalSection()),
48 expected_bitrate_bps_(0),
49 start_bitrate_bps_(0),
50 rtx_media_ssrcs_(rtx_media_ssrcs),
51 total_sent_(0),
52 padding_sent_(0),
53 rtx_media_sent_(0),
54 total_packets_sent_(0),
55 padding_packets_sent_(0),
56 rtx_media_packets_sent_(0),
57 test_start_ms_(clock_->TimeInMilliseconds()),
58 ramp_up_finished_ms_(0) {
59 // Ideally we would only have to instantiate an RtcpSender, an
60 // RtpHeaderParser and a RemoteBitrateEstimator here, but due to the current
61 // state of the RTP module we need a full module and receive statistics to
62 // be able to produce an RTCP with REMB.
63 RtpRtcp::Configuration config;
64 config.receive_statistics = receive_stats_.get();
65 feedback_transport_.Enable();
66 config.outgoing_transport = &feedback_transport_;
67 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
68 rtp_rtcp_->SetREMBStatus(true);
69 rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
70 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
71 kAbsSendTimeExtensionId);
72 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
73 kTransmissionTimeOffsetExtensionId);
74 const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
75 remote_bitrate_estimator_.reset(
76 rbe_factory->Create(this, clock, control_type,
77 kRemoteBitrateEstimatorMinBitrateBps));
78}
79
80void StreamObserver::set_expected_bitrate_bps(
81 unsigned int expected_bitrate_bps) {
82 CriticalSectionScoped lock(crit_.get());
83 expected_bitrate_bps_ = expected_bitrate_bps;
84}
85
86void StreamObserver::set_start_bitrate_bps(unsigned int start_bitrate_bps) {
87 CriticalSectionScoped lock(crit_.get());
88 start_bitrate_bps_ = start_bitrate_bps;
89}
90
91void StreamObserver::OnReceiveBitrateChanged(
92 const std::vector<unsigned int>& ssrcs, unsigned int bitrate) {
93 CriticalSectionScoped lock(crit_.get());
94 assert(expected_bitrate_bps_ > 0);
95 if (start_bitrate_bps_ != 0) {
96 // For tests with an explicitly set start bitrate, verify the first
97 // bitrate estimate is close to the start bitrate and lower than the
98 // test target bitrate. This is to verify a call respects the configured
99 // start bitrate, but due to the BWE implementation we can't guarantee the
100 // first estimate really is as high as the start bitrate.
101 EXPECT_GT(bitrate, 0.9 * start_bitrate_bps_);
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000102 start_bitrate_bps_ = 0;
103 }
104 if (bitrate >= expected_bitrate_bps_) {
105 ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
106 // Just trigger if there was any rtx padding packet.
107 if (rtx_media_ssrcs_.empty() || rtx_media_sent_ > 0) {
108 TriggerTestDone();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000109 }
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000110 }
111 rtp_rtcp_->SetREMBData(
112 bitrate, static_cast<uint8_t>(ssrcs.size()), &ssrcs[0]);
113 rtp_rtcp_->Process();
114}
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000115
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000116bool StreamObserver::SendRtp(const uint8_t* packet, size_t length) {
117 CriticalSectionScoped lock(crit_.get());
118 RTPHeader header;
119 EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
120 receive_stats_->IncomingPacket(header, length, false);
121 payload_registry_->SetIncomingPayloadType(header);
122 remote_bitrate_estimator_->IncomingPacket(
123 clock_->TimeInMilliseconds(), static_cast<int>(length - 12), header);
124 if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) {
125 remote_bitrate_estimator_->Process();
126 }
127 total_sent_ += length;
128 padding_sent_ += header.paddingLength;
129 ++total_packets_sent_;
130 if (header.paddingLength > 0)
131 ++padding_packets_sent_;
132 if (rtx_media_ssrcs_.find(header.ssrc) != rtx_media_ssrcs_.end()) {
133 rtx_media_sent_ += length - header.headerLength - header.paddingLength;
134 if (header.paddingLength == 0)
135 ++rtx_media_packets_sent_;
136 uint8_t restored_packet[kMaxPacketSize];
137 uint8_t* restored_packet_ptr = restored_packet;
138 int restored_length = static_cast<int>(length);
139 payload_registry_->RestoreOriginalPacket(&restored_packet_ptr,
140 packet,
141 &restored_length,
142 rtx_media_ssrcs_[header.ssrc],
143 header);
144 length = restored_length;
145 EXPECT_TRUE(rtp_parser_->Parse(
146 restored_packet, static_cast<int>(length), &header));
147 } else {
148 rtp_rtcp_->SetRemoteSSRC(header.ssrc);
149 }
150 return true;
151}
152
153bool StreamObserver::SendRtcp(const uint8_t* packet, size_t length) {
154 return true;
155}
156
pbos@webrtc.org32452b22014-10-22 12:15:24 +0000157EventTypeWrapper StreamObserver::Wait() {
158 return test_done_->Wait(test::CallTest::kLongTimeoutMs);
159}
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000160
161void StreamObserver::ReportResult(const std::string& measurement,
162 size_t value,
163 const std::string& units) {
164 webrtc::test::PrintResult(
165 measurement, "",
166 ::testing::UnitTest::GetInstance()->current_test_info()->name(),
167 value, units, false);
168}
169
170void StreamObserver::TriggerTestDone() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
171 ReportResult("ramp-up-total-sent", total_sent_, "bytes");
172 ReportResult("ramp-up-padding-sent", padding_sent_, "bytes");
173 ReportResult("ramp-up-rtx-media-sent", rtx_media_sent_, "bytes");
174 ReportResult("ramp-up-total-packets-sent", total_packets_sent_, "packets");
175 ReportResult("ramp-up-padding-packets-sent",
176 padding_packets_sent_,
177 "packets");
178 ReportResult("ramp-up-rtx-packets-sent",
179 rtx_media_packets_sent_,
180 "packets");
181 ReportResult("ramp-up-time",
182 ramp_up_finished_ms_ - test_start_ms_,
183 "milliseconds");
184 test_done_->Set();
185}
186
187LowRateStreamObserver::LowRateStreamObserver(
188 newapi::Transport* feedback_transport,
189 Clock* clock,
190 size_t number_of_streams,
191 bool rtx_used)
192 : clock_(clock),
193 number_of_streams_(number_of_streams),
194 rtx_used_(rtx_used),
195 test_done_(EventWrapper::Create()),
196 rtp_parser_(RtpHeaderParser::Create()),
197 feedback_transport_(feedback_transport),
198 receive_stats_(ReceiveStatistics::Create(clock)),
199 crit_(CriticalSectionWrapper::CreateCriticalSection()),
200 send_stream_(NULL),
201 test_state_(kFirstRampup),
202 state_start_ms_(clock_->TimeInMilliseconds()),
203 interval_start_ms_(state_start_ms_),
204 last_remb_bps_(0),
205 sent_bytes_(0),
206 total_overuse_bytes_(0),
207 suspended_in_stats_(false) {
208 RtpRtcp::Configuration config;
209 config.receive_statistics = receive_stats_.get();
210 feedback_transport_.Enable();
211 config.outgoing_transport = &feedback_transport_;
212 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
213 rtp_rtcp_->SetREMBStatus(true);
214 rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
215 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
216 kTransmissionTimeOffsetExtensionId);
217 AbsoluteSendTimeRemoteBitrateEstimatorFactory rbe_factory;
218 const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 10000;
219 remote_bitrate_estimator_.reset(
220 rbe_factory.Create(this, clock, kMimdControl,
221 kRemoteBitrateEstimatorMinBitrateBps));
222 forward_transport_config_.link_capacity_kbps =
223 kHighBandwidthLimitBps / 1000;
stefan@webrtc.orgb8e9e442014-07-09 11:29:06 +0000224 forward_transport_config_.queue_length_packets = 100; // Something large.
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000225 test::DirectTransport::SetConfig(forward_transport_config_);
226 test::DirectTransport::SetReceiver(this);
227}
228
229void LowRateStreamObserver::SetSendStream(const VideoSendStream* send_stream) {
230 CriticalSectionScoped lock(crit_.get());
231 send_stream_ = send_stream;
232}
233
234void LowRateStreamObserver::OnReceiveBitrateChanged(
235 const std::vector<unsigned int>& ssrcs,
236 unsigned int bitrate) {
237 CriticalSectionScoped lock(crit_.get());
238 rtp_rtcp_->SetREMBData(
239 bitrate, static_cast<uint8_t>(ssrcs.size()), &ssrcs[0]);
240 rtp_rtcp_->Process();
241 last_remb_bps_ = bitrate;
242}
243
244bool LowRateStreamObserver::SendRtp(const uint8_t* data, size_t length) {
245 CriticalSectionScoped lock(crit_.get());
246 sent_bytes_ += length;
247 int64_t now_ms = clock_->TimeInMilliseconds();
248 if (now_ms > interval_start_ms_ + 1000) { // Let at least 1 second pass.
249 // Verify that the send rate was about right.
250 unsigned int average_rate_bps = static_cast<unsigned int>(sent_bytes_) *
251 8 * 1000 / (now_ms - interval_start_ms_);
252 // TODO(holmer): Why is this failing?
253 // EXPECT_LT(average_rate_bps, last_remb_bps_ * 1.1);
254 if (average_rate_bps > last_remb_bps_ * 1.1) {
255 total_overuse_bytes_ +=
256 sent_bytes_ -
257 last_remb_bps_ / 8 * (now_ms - interval_start_ms_) / 1000;
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +0000258 }
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000259 EvolveTestState(average_rate_bps);
260 interval_start_ms_ = now_ms;
261 sent_bytes_ = 0;
262 }
263 return test::DirectTransport::SendRtp(data, length);
264}
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000265
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000266PacketReceiver::DeliveryStatus LowRateStreamObserver::DeliverPacket(
267 const uint8_t* packet, size_t length) {
268 CriticalSectionScoped lock(crit_.get());
269 RTPHeader header;
270 EXPECT_TRUE(rtp_parser_->Parse(packet, static_cast<int>(length), &header));
271 receive_stats_->IncomingPacket(header, length, false);
272 remote_bitrate_estimator_->IncomingPacket(
273 clock_->TimeInMilliseconds(), static_cast<int>(length - 12), header);
274 if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) {
275 remote_bitrate_estimator_->Process();
276 }
277 suspended_in_stats_ = send_stream_->GetStats().suspended;
278 return DELIVERY_OK;
279}
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000280
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000281bool LowRateStreamObserver::SendRtcp(const uint8_t* packet, size_t length) {
282 return true;
283}
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000284
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000285std::string LowRateStreamObserver::GetModifierString() {
286 std::string str("_");
287 char temp_str[5];
288 sprintf(temp_str, "%i",
289 static_cast<int>(number_of_streams_));
290 str += std::string(temp_str);
291 str += "stream";
292 str += (number_of_streams_ > 1 ? "s" : "");
293 str += "_";
294 str += (rtx_used_ ? "" : "no");
295 str += "rtx";
296 return str;
297}
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000298
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000299void LowRateStreamObserver::EvolveTestState(unsigned int bitrate_bps) {
300 int64_t now = clock_->TimeInMilliseconds();
301 CriticalSectionScoped lock(crit_.get());
302 assert(send_stream_ != NULL);
303 switch (test_state_) {
304 case kFirstRampup: {
305 EXPECT_FALSE(suspended_in_stats_);
306 if (bitrate_bps > kExpectedHighBitrateBps) {
307 // The first ramp-up has reached the target bitrate. Change the
308 // channel limit, and move to the next test state.
309 forward_transport_config_.link_capacity_kbps =
310 kLowBandwidthLimitBps / 1000;
311 test::DirectTransport::SetConfig(forward_transport_config_);
312 test_state_ = kLowRate;
313 webrtc::test::PrintResult("ramp_up_down_up",
314 GetModifierString(),
315 "first_rampup",
316 now - state_start_ms_,
317 "ms",
318 false);
319 state_start_ms_ = now;
320 interval_start_ms_ = now;
321 sent_bytes_ = 0;
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000322 }
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000323 break;
pbos@webrtc.orgf577ae92014-03-19 08:43:57 +0000324 }
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000325 case kLowRate: {
326 if (bitrate_bps < kExpectedLowBitrateBps && suspended_in_stats_) {
327 // The ramp-down was successful. Change the channel limit back to a
328 // high value, and move to the next test state.
329 forward_transport_config_.link_capacity_kbps =
330 kHighBandwidthLimitBps / 1000;
331 test::DirectTransport::SetConfig(forward_transport_config_);
332 test_state_ = kSecondRampup;
333 webrtc::test::PrintResult("ramp_up_down_up",
334 GetModifierString(),
335 "rampdown",
336 now - state_start_ms_,
337 "ms",
338 false);
339 state_start_ms_ = now;
340 interval_start_ms_ = now;
341 sent_bytes_ = 0;
342 }
343 break;
344 }
345 case kSecondRampup: {
346 if (bitrate_bps > kExpectedHighBitrateBps && !suspended_in_stats_) {
347 webrtc::test::PrintResult("ramp_up_down_up",
348 GetModifierString(),
349 "second_rampup",
350 now - state_start_ms_,
351 "ms",
352 false);
353 webrtc::test::PrintResult("ramp_up_down_up",
354 GetModifierString(),
355 "total_overuse",
356 total_overuse_bytes_,
357 "bytes",
358 false);
359 test_done_->Set();
360 }
361 break;
362 }
363 }
364}
pbos@webrtc.orgf577ae92014-03-19 08:43:57 +0000365
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000366EventTypeWrapper LowRateStreamObserver::Wait() {
367 return test_done_->Wait(test::CallTest::kLongTimeoutMs);
368}
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000369
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000370void RampUpTest::RunRampUpTest(bool rtx,
371 size_t num_streams,
372 unsigned int start_bitrate_bps,
373 const std::string& extension_type) {
374 std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100));
375 std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200));
376 StreamObserver::SsrcMap rtx_ssrc_map;
377 if (rtx) {
378 for (size_t i = 0; i < ssrcs.size(); ++i)
379 rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i];
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000380 }
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +0000381
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000382 CreateSendConfig(num_streams);
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +0000383
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000384 scoped_ptr<RemoteBitrateEstimatorFactory> rbe_factory;
385 RateControlType control_type;
386 if (extension_type == RtpExtension::kAbsSendTime) {
387 control_type = kAimdControl;
388 rbe_factory.reset(new AbsoluteSendTimeRemoteBitrateEstimatorFactory);
pbos@webrtc.org994d0b72014-06-27 08:47:52 +0000389 send_config_.rtp.extensions.push_back(RtpExtension(
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000390 extension_type.c_str(), kAbsSendTimeExtensionId));
391 } else {
392 control_type = kMimdControl;
393 rbe_factory.reset(new RemoteBitrateEstimatorFactory);
394 send_config_.rtp.extensions.push_back(RtpExtension(
395 extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +0000396 }
397
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000398 test::DirectTransport receiver_transport;
399 StreamObserver stream_observer(rtx_ssrc_map,
400 &receiver_transport,
401 Clock::GetRealTimeClock(),
402 rbe_factory.get(),
403 control_type);
404
405 Call::Config call_config(&stream_observer);
406 if (start_bitrate_bps != 0) {
pbos@webrtc.orga73a6782014-10-14 11:52:10 +0000407 call_config.stream_start_bitrate_bps = start_bitrate_bps;
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000408 stream_observer.set_start_bitrate_bps(start_bitrate_bps);
andresp@webrtc.orga714eaf2014-03-17 15:34:57 +0000409 }
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000410
411 CreateSenderCall(call_config);
412
413 receiver_transport.SetReceiver(sender_call_->Receiver());
414
415 if (num_streams == 1) {
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000416 encoder_config_.streams[0].target_bitrate_bps = 2000000;
417 encoder_config_.streams[0].max_bitrate_bps = 2000000;
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000418 }
419
420 send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
421 send_config_.rtp.ssrcs = ssrcs;
422 if (rtx) {
423 send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
424 send_config_.rtp.rtx.ssrcs = rtx_ssrcs;
425 send_config_.rtp.rtx.pad_with_redundant_payloads = true;
426 }
427
428 if (num_streams == 1) {
429 // For single stream rampup until 1mbps
430 stream_observer.set_expected_bitrate_bps(kSingleStreamTargetBps);
431 } else {
432 // For multi stream rampup until all streams are being sent. That means
433 // enough birate to send all the target streams plus the min bitrate of
434 // the last one.
pbos@webrtc.orgbbe0a852014-09-19 12:30:25 +0000435 int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
436 for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
437 expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000438 }
439 stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
440 }
441
442 CreateStreams();
443 CreateFrameGeneratorCapturer();
444
445 Start();
446
447 EXPECT_EQ(kEventSignaled, stream_observer.Wait());
448
449 Stop();
450 DestroyStreams();
451}
452
453void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams, bool rtx) {
454 test::DirectTransport receiver_transport;
455 LowRateStreamObserver stream_observer(
456 &receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx);
457
458 Call::Config call_config(&stream_observer);
459 CreateSenderCall(call_config);
460 receiver_transport.SetReceiver(sender_call_->Receiver());
461
462 CreateSendConfig(number_of_streams);
463
464 send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
465 send_config_.rtp.extensions.push_back(RtpExtension(
466 RtpExtension::kTOffset, kTransmissionTimeOffsetExtensionId));
467 send_config_.suspend_below_min_bitrate = true;
468 if (rtx) {
469 send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
470 send_config_.rtp.rtx.ssrcs = GenerateSsrcs(number_of_streams, 200);
471 send_config_.rtp.rtx.pad_with_redundant_payloads = true;
472 }
473
474 CreateStreams();
475 stream_observer.SetSendStream(send_stream_);
476
477 CreateFrameGeneratorCapturer();
478
479 Start();
480
481 EXPECT_EQ(kEventSignaled, stream_observer.Wait());
482
483 Stop();
484 DestroyStreams();
485}
pbos@webrtc.org744fbc72013-09-10 09:26:25 +0000486
stefan@webrtc.orgcb254aa2014-06-12 15:12:25 +0000487TEST_F(RampUpTest, SingleStream) {
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000488 RunRampUpTest(false, 1, 0, RtpExtension::kTOffset);
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000489}
pbos@webrtc.org744fbc72013-09-10 09:26:25 +0000490
stefan@webrtc.orgcb254aa2014-06-12 15:12:25 +0000491TEST_F(RampUpTest, Simulcast) {
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000492 RunRampUpTest(false, 3, 0, RtpExtension::kTOffset);
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000493}
494
stefan@webrtc.orgcb254aa2014-06-12 15:12:25 +0000495TEST_F(RampUpTest, SimulcastWithRtx) {
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000496 RunRampUpTest(true, 3, 0, RtpExtension::kTOffset);
mflodman@webrtc.orgeb16b812014-06-16 08:57:39 +0000497}
498
499TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
stefan@webrtc.org3d7da882014-07-08 13:59:46 +0000500 RunRampUpTest(false, 1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset);
andresp@webrtc.orgc1480792014-03-20 03:23:55 +0000501}
pbos@webrtc.org744fbc72013-09-10 09:26:25 +0000502
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +0000503TEST_F(RampUpTest, UpDownUpOneStream) { RunRampUpDownUpTest(1, false); }
504
henrik.lundin@webrtc.org6ea4f632014-03-13 09:21:26 +0000505TEST_F(RampUpTest, UpDownUpThreeStreams) { RunRampUpDownUpTest(3, false); }
henrik.lundin@webrtc.org998cb8f2014-03-06 09:12:00 +0000506
henrik.lundin@webrtc.org6ea4f632014-03-13 09:21:26 +0000507TEST_F(RampUpTest, UpDownUpOneStreamRtx) { RunRampUpDownUpTest(1, true); }
henrik.lundin@webrtc.org998cb8f2014-03-06 09:12:00 +0000508
henrik.lundin@webrtc.org6ea4f632014-03-13 09:21:26 +0000509TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) { RunRampUpDownUpTest(3, true); }
henrik.lundin@webrtc.org845862f2014-03-06 07:19:28 +0000510
pbos@webrtc.org744fbc72013-09-10 09:26:25 +0000511} // namespace webrtc