1 /*
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 */
10
11 #include "webrtc/call/rampup_tests.h"
12
13 #include "webrtc/base/checks.h"
14 #include "webrtc/base/platform_thread.h"
15 #include "webrtc/test/encoder_settings.h"
16 #include "webrtc/test/gtest.h"
17 #include "webrtc/test/testsupport/perf_test.h"
18
19 namespace webrtc {
20 namespace {
21
22 static const int64_t kPollIntervalMs = 20;
23 static const int kExpectedHighVideoBitrateBps = 60000;
24 static const int kExpectedHighAudioBitrateBps = 30000;
25 static const int kLowBandwidthLimitBps = 20000;
26 static const int kExpectedLowBitrateBps = 20000;
27
GenerateSsrcs(size_t num_streams,uint32_t ssrc_offset)28 std::vector<uint32_t> GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) {
29 std::vector<uint32_t> ssrcs;
30 for (size_t i = 0; i != num_streams; ++i)
31 ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
32 return ssrcs;
33 }
34 } // namespace
35
RampUpTester(size_t num_video_streams,size_t num_audio_streams,unsigned int start_bitrate_bps,const std::string & extension_type,bool rtx,bool red)36 RampUpTester::RampUpTester(size_t num_video_streams,
37 size_t num_audio_streams,
38 unsigned int start_bitrate_bps,
39 const std::string& extension_type,
40 bool rtx,
41 bool red)
42 : EndToEndTest(test::CallTest::kLongTimeoutMs),
43 event_(false, false),
44 clock_(Clock::GetRealTimeClock()),
45 num_video_streams_(num_video_streams),
46 num_audio_streams_(num_audio_streams),
47 rtx_(rtx),
48 red_(red),
49 sender_call_(nullptr),
50 send_stream_(nullptr),
51 start_bitrate_bps_(start_bitrate_bps),
52 start_bitrate_verified_(false),
53 expected_bitrate_bps_(0),
54 test_start_ms_(-1),
55 ramp_up_finished_ms_(-1),
56 extension_type_(extension_type),
57 video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
58 video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
59 audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
60 poller_thread_(&BitrateStatsPollingThread,
61 this,
62 "BitrateStatsPollingThread") {
63 EXPECT_LE(num_audio_streams_, 1u);
64 }
65
~RampUpTester()66 RampUpTester::~RampUpTester() {
67 event_.Set();
68 }
69
GetSenderCallConfig()70 Call::Config RampUpTester::GetSenderCallConfig() {
71 Call::Config call_config(&event_log_);
72 if (start_bitrate_bps_ != 0) {
73 call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
74 }
75 call_config.bitrate_config.min_bitrate_bps = 10000;
76 return call_config;
77 }
78
OnVideoStreamsCreated(VideoSendStream * send_stream,const std::vector<VideoReceiveStream * > & receive_streams)79 void RampUpTester::OnVideoStreamsCreated(
80 VideoSendStream* send_stream,
81 const std::vector<VideoReceiveStream*>& receive_streams) {
82 send_stream_ = send_stream;
83 }
84
CreateSendTransport(Call * sender_call)85 test::PacketTransport* RampUpTester::CreateSendTransport(Call* sender_call) {
86 send_transport_ = new test::PacketTransport(sender_call, this,
87 test::PacketTransport::kSender,
88 forward_transport_config_);
89 return send_transport_;
90 }
91
GetNumVideoStreams() const92 size_t RampUpTester::GetNumVideoStreams() const {
93 return num_video_streams_;
94 }
95
GetNumAudioStreams() const96 size_t RampUpTester::GetNumAudioStreams() const {
97 return num_audio_streams_;
98 }
99
100 class RampUpTester::VideoStreamFactory
101 : public VideoEncoderConfig::VideoStreamFactoryInterface {
102 public:
VideoStreamFactory()103 VideoStreamFactory() {}
104
105 private:
CreateEncoderStreams(int width,int height,const VideoEncoderConfig & encoder_config)106 std::vector<VideoStream> CreateEncoderStreams(
107 int width,
108 int height,
109 const VideoEncoderConfig& encoder_config) override {
110 std::vector<VideoStream> streams =
111 test::CreateVideoStreams(width, height, encoder_config);
112 if (encoder_config.number_of_streams == 1) {
113 streams[0].target_bitrate_bps = streams[0].max_bitrate_bps = 2000000;
114 }
115 return streams;
116 }
117 };
118
ModifyVideoConfigs(VideoSendStream::Config * send_config,std::vector<VideoReceiveStream::Config> * receive_configs,VideoEncoderConfig * encoder_config)119 void RampUpTester::ModifyVideoConfigs(
120 VideoSendStream::Config* send_config,
121 std::vector<VideoReceiveStream::Config>* receive_configs,
122 VideoEncoderConfig* encoder_config) {
123 send_config->suspend_below_min_bitrate = true;
124 encoder_config->number_of_streams = num_video_streams_;
125 encoder_config->max_bitrate_bps = 2000000;
126 encoder_config->video_stream_factory =
127 new rtc::RefCountedObject<RampUpTester::VideoStreamFactory>();
128 if (num_video_streams_ == 1) {
129 // For single stream rampup until 1mbps
130 expected_bitrate_bps_ = kSingleStreamTargetBps;
131 } else {
132 // For multi stream rampup until all streams are being sent. That means
133 // enough bitrate to send all the target streams plus the min bitrate of
134 // the last one.
135 std::vector<VideoStream> streams = test::CreateVideoStreams(
136 test::CallTest::kDefaultWidth, test::CallTest::kDefaultHeight,
137 *encoder_config);
138 expected_bitrate_bps_ = streams.back().min_bitrate_bps;
139 for (size_t i = 0; i < streams.size() - 1; ++i) {
140 expected_bitrate_bps_ += streams[i].target_bitrate_bps;
141 }
142 }
143
144 send_config->rtp.extensions.clear();
145
146 bool remb;
147 bool transport_cc;
148 if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
149 remb = true;
150 transport_cc = false;
151 send_config->rtp.extensions.push_back(
152 RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
153 } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
154 remb = false;
155 transport_cc = true;
156 send_config->rtp.extensions.push_back(RtpExtension(
157 extension_type_.c_str(), kTransportSequenceNumberExtensionId));
158 } else {
159 remb = true;
160 transport_cc = false;
161 send_config->rtp.extensions.push_back(RtpExtension(
162 extension_type_.c_str(), kTransmissionTimeOffsetExtensionId));
163 }
164
165 send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
166 send_config->rtp.ssrcs = video_ssrcs_;
167 if (rtx_) {
168 send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
169 send_config->rtp.rtx.ssrcs = video_rtx_ssrcs_;
170 }
171 if (red_) {
172 send_config->rtp.ulpfec.ulpfec_payload_type =
173 test::CallTest::kUlpfecPayloadType;
174 send_config->rtp.ulpfec.red_payload_type = test::CallTest::kRedPayloadType;
175 if (rtx_) {
176 send_config->rtp.ulpfec.red_rtx_payload_type =
177 test::CallTest::kRtxRedPayloadType;
178 }
179 }
180
181 size_t i = 0;
182 for (VideoReceiveStream::Config& recv_config : *receive_configs) {
183 recv_config.rtp.remb = remb;
184 recv_config.rtp.transport_cc = transport_cc;
185 recv_config.rtp.extensions = send_config->rtp.extensions;
186
187 recv_config.rtp.remote_ssrc = video_ssrcs_[i];
188 recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms;
189
190 if (red_) {
191 recv_config.rtp.ulpfec.red_payload_type =
192 send_config->rtp.ulpfec.red_payload_type;
193 recv_config.rtp.ulpfec.ulpfec_payload_type =
194 send_config->rtp.ulpfec.ulpfec_payload_type;
195 if (rtx_) {
196 recv_config.rtp.ulpfec.red_rtx_payload_type =
197 send_config->rtp.ulpfec.red_rtx_payload_type;
198 }
199 }
200
201 if (rtx_) {
202 recv_config.rtp.rtx[send_config->encoder_settings.payload_type].ssrc =
203 video_rtx_ssrcs_[i];
204 recv_config.rtp.rtx[send_config->encoder_settings.payload_type]
205 .payload_type = send_config->rtp.rtx.payload_type;
206 }
207 ++i;
208 }
209 }
210
ModifyAudioConfigs(AudioSendStream::Config * send_config,std::vector<AudioReceiveStream::Config> * receive_configs)211 void RampUpTester::ModifyAudioConfigs(
212 AudioSendStream::Config* send_config,
213 std::vector<AudioReceiveStream::Config>* receive_configs) {
214 if (num_audio_streams_ == 0)
215 return;
216
217 EXPECT_NE(RtpExtension::kTimestampOffsetUri, extension_type_)
218 << "Audio BWE not supported with toffset.";
219
220 send_config->rtp.ssrc = audio_ssrcs_[0];
221 send_config->rtp.extensions.clear();
222
223 send_config->min_bitrate_bps = 6000;
224 send_config->max_bitrate_bps = 60000;
225
226 bool transport_cc = false;
227 if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
228 transport_cc = false;
229 send_config->rtp.extensions.push_back(
230 RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
231 } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
232 transport_cc = true;
233 send_config->rtp.extensions.push_back(RtpExtension(
234 extension_type_.c_str(), kTransportSequenceNumberExtensionId));
235 }
236
237 for (AudioReceiveStream::Config& recv_config : *receive_configs) {
238 recv_config.rtp.transport_cc = transport_cc;
239 recv_config.rtp.extensions = send_config->rtp.extensions;
240 recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
241 }
242 }
243
OnCallsCreated(Call * sender_call,Call * receiver_call)244 void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
245 sender_call_ = sender_call;
246 }
247
BitrateStatsPollingThread(void * obj)248 bool RampUpTester::BitrateStatsPollingThread(void* obj) {
249 return static_cast<RampUpTester*>(obj)->PollStats();
250 }
251
PollStats()252 bool RampUpTester::PollStats() {
253 if (sender_call_) {
254 Call::Stats stats = sender_call_->GetStats();
255
256 RTC_DCHECK_GT(expected_bitrate_bps_, 0);
257 if (!start_bitrate_verified_ && start_bitrate_bps_ != 0) {
258 // For tests with an explicitly set start bitrate, verify the first
259 // bitrate estimate is close to the start bitrate and lower than the
260 // test target bitrate. This is to verify a call respects the configured
261 // start bitrate, but due to the BWE implementation we can't guarantee the
262 // first estimate really is as high as the start bitrate.
263 EXPECT_GT(stats.send_bandwidth_bps, 0.9 * start_bitrate_bps_);
264 start_bitrate_verified_ = true;
265 }
266 if (stats.send_bandwidth_bps >= expected_bitrate_bps_) {
267 ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
268 observation_complete_.Set();
269 }
270 }
271
272 return !event_.Wait(kPollIntervalMs);
273 }
274
ReportResult(const std::string & measurement,size_t value,const std::string & units) const275 void RampUpTester::ReportResult(const std::string& measurement,
276 size_t value,
277 const std::string& units) const {
278 webrtc::test::PrintResult(
279 measurement, "",
280 ::testing::UnitTest::GetInstance()->current_test_info()->name(), value,
281 units, false);
282 }
283
AccumulateStats(const VideoSendStream::StreamStats & stream,size_t * total_packets_sent,size_t * total_sent,size_t * padding_sent,size_t * media_sent) const284 void RampUpTester::AccumulateStats(const VideoSendStream::StreamStats& stream,
285 size_t* total_packets_sent,
286 size_t* total_sent,
287 size_t* padding_sent,
288 size_t* media_sent) const {
289 *total_packets_sent += stream.rtp_stats.transmitted.packets +
290 stream.rtp_stats.retransmitted.packets +
291 stream.rtp_stats.fec.packets;
292 *total_sent += stream.rtp_stats.transmitted.TotalBytes() +
293 stream.rtp_stats.retransmitted.TotalBytes() +
294 stream.rtp_stats.fec.TotalBytes();
295 *padding_sent += stream.rtp_stats.transmitted.padding_bytes +
296 stream.rtp_stats.retransmitted.padding_bytes +
297 stream.rtp_stats.fec.padding_bytes;
298 *media_sent += stream.rtp_stats.MediaPayloadBytes();
299 }
300
TriggerTestDone()301 void RampUpTester::TriggerTestDone() {
302 RTC_DCHECK_GE(test_start_ms_, 0);
303
304 // TODO(holmer): Add audio send stats here too when those APIs are available.
305 if (!send_stream_)
306 return;
307
308 VideoSendStream::Stats send_stats = send_stream_->GetStats();
309
310 size_t total_packets_sent = 0;
311 size_t total_sent = 0;
312 size_t padding_sent = 0;
313 size_t media_sent = 0;
314 for (uint32_t ssrc : video_ssrcs_) {
315 AccumulateStats(send_stats.substreams[ssrc], &total_packets_sent,
316 &total_sent, &padding_sent, &media_sent);
317 }
318
319 size_t rtx_total_packets_sent = 0;
320 size_t rtx_total_sent = 0;
321 size_t rtx_padding_sent = 0;
322 size_t rtx_media_sent = 0;
323 for (uint32_t rtx_ssrc : video_rtx_ssrcs_) {
324 AccumulateStats(send_stats.substreams[rtx_ssrc], &rtx_total_packets_sent,
325 &rtx_total_sent, &rtx_padding_sent, &rtx_media_sent);
326 }
327
328 ReportResult("ramp-up-total-packets-sent", total_packets_sent, "packets");
329 ReportResult("ramp-up-total-sent", total_sent, "bytes");
330 ReportResult("ramp-up-media-sent", media_sent, "bytes");
331 ReportResult("ramp-up-padding-sent", padding_sent, "bytes");
332 ReportResult("ramp-up-rtx-total-packets-sent", rtx_total_packets_sent,
333 "packets");
334 ReportResult("ramp-up-rtx-total-sent", rtx_total_sent, "bytes");
335 ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, "bytes");
336 ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, "bytes");
337 if (ramp_up_finished_ms_ >= 0) {
338 ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_,
339 "milliseconds");
340 }
341 ReportResult("ramp-up-average-network-latency",
342 send_transport_->GetAverageDelayMs(), "milliseconds");
343 }
344
PerformTest()345 void RampUpTester::PerformTest() {
346 test_start_ms_ = clock_->TimeInMilliseconds();
347 poller_thread_.Start();
348 EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
349 TriggerTestDone();
350 poller_thread_.Stop();
351 }
352
RampUpDownUpTester(size_t num_video_streams,size_t num_audio_streams,unsigned int start_bitrate_bps,const std::string & extension_type,bool rtx,bool red)353 RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
354 size_t num_audio_streams,
355 unsigned int start_bitrate_bps,
356 const std::string& extension_type,
357 bool rtx,
358 bool red)
359 : RampUpTester(num_video_streams,
360 num_audio_streams,
361 start_bitrate_bps,
362 extension_type,
363 rtx,
364 red),
365 test_state_(kFirstRampup),
366 state_start_ms_(clock_->TimeInMilliseconds()),
367 interval_start_ms_(clock_->TimeInMilliseconds()),
368 sent_bytes_(0) {
369 forward_transport_config_.link_capacity_kbps = GetHighLinkCapacity();
370 }
371
~RampUpDownUpTester()372 RampUpDownUpTester::~RampUpDownUpTester() {}
373
PollStats()374 bool RampUpDownUpTester::PollStats() {
375 if (send_stream_) {
376 webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
377 int transmit_bitrate_bps = 0;
378 for (auto it : stats.substreams) {
379 transmit_bitrate_bps += it.second.total_bitrate_bps;
380 }
381 EvolveTestState(transmit_bitrate_bps, stats.suspended);
382 } else if (num_audio_streams_ > 0 && sender_call_ != nullptr) {
383 // An audio send stream doesn't have bitrate stats, so the call send BW is
384 // currently used instead.
385 int transmit_bitrate_bps = sender_call_->GetStats().send_bandwidth_bps;
386 EvolveTestState(transmit_bitrate_bps, false);
387 }
388
389 return !event_.Wait(kPollIntervalMs);
390 }
391
GetReceiverCallConfig()392 Call::Config RampUpDownUpTester::GetReceiverCallConfig() {
393 Call::Config config(&event_log_);
394 config.bitrate_config.min_bitrate_bps = 10000;
395 return config;
396 }
397
GetModifierString() const398 std::string RampUpDownUpTester::GetModifierString() const {
399 std::string str("_");
400 if (num_video_streams_ > 0) {
401 std::ostringstream s;
402 s << num_video_streams_;
403 str += s.str();
404 str += "stream";
405 str += (num_video_streams_ > 1 ? "s" : "");
406 str += "_";
407 }
408 if (num_audio_streams_ > 0) {
409 std::ostringstream s;
410 s << num_audio_streams_;
411 str += s.str();
412 str += "stream";
413 str += (num_audio_streams_ > 1 ? "s" : "");
414 str += "_";
415 }
416 str += (rtx_ ? "" : "no");
417 str += "rtx";
418 return str;
419 }
420
GetExpectedHighBitrate() const421 int RampUpDownUpTester::GetExpectedHighBitrate() const {
422 int expected_bitrate_bps = 0;
423 if (num_audio_streams_ > 0)
424 expected_bitrate_bps += kExpectedHighAudioBitrateBps;
425 if (num_video_streams_ > 0)
426 expected_bitrate_bps += kExpectedHighVideoBitrateBps;
427 return expected_bitrate_bps;
428 }
429
GetHighLinkCapacity() const430 int RampUpDownUpTester::GetHighLinkCapacity() const {
431 return 4 * GetExpectedHighBitrate() / (3 * 1000);
432 }
433
EvolveTestState(int bitrate_bps,bool suspended)434 void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
435 int64_t now = clock_->TimeInMilliseconds();
436 switch (test_state_) {
437 case kFirstRampup: {
438 EXPECT_FALSE(suspended);
439 if (bitrate_bps >= GetExpectedHighBitrate()) {
440 // The first ramp-up has reached the target bitrate. Change the
441 // channel limit, and move to the next test state.
442 forward_transport_config_.link_capacity_kbps =
443 kLowBandwidthLimitBps / 1000;
444 send_transport_->SetConfig(forward_transport_config_);
445 test_state_ = kLowRate;
446 webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
447 "first_rampup", now - state_start_ms_, "ms",
448 false);
449 state_start_ms_ = now;
450 interval_start_ms_ = now;
451 sent_bytes_ = 0;
452 }
453 break;
454 }
455 case kLowRate: {
456 // Audio streams are never suspended.
457 bool check_suspend_state = num_video_streams_ > 0;
458 if (bitrate_bps < kExpectedLowBitrateBps &&
459 suspended == check_suspend_state) {
460 // The ramp-down was successful. Change the channel limit back to a
461 // high value, and move to the next test state.
462 forward_transport_config_.link_capacity_kbps = GetHighLinkCapacity();
463 send_transport_->SetConfig(forward_transport_config_);
464 test_state_ = kSecondRampup;
465 webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
466 "rampdown", now - state_start_ms_, "ms",
467 false);
468 state_start_ms_ = now;
469 interval_start_ms_ = now;
470 sent_bytes_ = 0;
471 }
472 break;
473 }
474 case kSecondRampup: {
475 if (bitrate_bps >= GetExpectedHighBitrate() && !suspended) {
476 webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
477 "second_rampup", now - state_start_ms_, "ms",
478 false);
479 ReportResult("ramp-up-down-up-average-network-latency",
480 send_transport_->GetAverageDelayMs(), "milliseconds");
481 observation_complete_.Set();
482 }
483 break;
484 }
485 }
486 }
487
488 class RampUpTest : public test::CallTest {
489 public:
RampUpTest()490 RampUpTest() {}
491
~RampUpTest()492 virtual ~RampUpTest() {
493 EXPECT_EQ(nullptr, video_send_stream_);
494 EXPECT_TRUE(video_receive_streams_.empty());
495 }
496 };
497
498 static const uint32_t kStartBitrateBps = 60000;
499
TEST_F(RampUpTest,UpDownUpAbsSendTimeSimulcastRedRtx)500 TEST_F(RampUpTest, UpDownUpAbsSendTimeSimulcastRedRtx) {
501 RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTimeUri,
502 true, true);
503 RunBaseTest(&test);
504 }
505
TEST_F(RampUpTest,UpDownUpTransportSequenceNumberRtx)506 TEST_F(RampUpTest, UpDownUpTransportSequenceNumberRtx) {
507 RampUpDownUpTester test(3, 0, kStartBitrateBps,
508 RtpExtension::kTransportSequenceNumberUri, true,
509 false);
510 RunBaseTest(&test);
511 }
512
TEST_F(RampUpTest,UpDownUpAudioVideoTransportSequenceNumberRtx)513 TEST_F(RampUpTest, UpDownUpAudioVideoTransportSequenceNumberRtx) {
514 RampUpDownUpTester test(3, 1, kStartBitrateBps,
515 RtpExtension::kTransportSequenceNumberUri, true,
516 false);
517 RunBaseTest(&test);
518 }
519
TEST_F(RampUpTest,UpDownUpAudioTransportSequenceNumberRtx)520 TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) {
521 RampUpDownUpTester test(0, 1, kStartBitrateBps,
522 RtpExtension::kTransportSequenceNumberUri, true,
523 false);
524 RunBaseTest(&test);
525 }
526
TEST_F(RampUpTest,TOffsetSimulcastRedRtx)527 TEST_F(RampUpTest, TOffsetSimulcastRedRtx) {
528 RampUpTester test(3, 0, 0, RtpExtension::kTimestampOffsetUri, true, true);
529 RunBaseTest(&test);
530 }
531
TEST_F(RampUpTest,AbsSendTime)532 TEST_F(RampUpTest, AbsSendTime) {
533 RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTimeUri, false, false);
534 RunBaseTest(&test);
535 }
536
TEST_F(RampUpTest,AbsSendTimeSimulcastRedRtx)537 TEST_F(RampUpTest, AbsSendTimeSimulcastRedRtx) {
538 RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTimeUri, true, true);
539 RunBaseTest(&test);
540 }
541
TEST_F(RampUpTest,TransportSequenceNumber)542 TEST_F(RampUpTest, TransportSequenceNumber) {
543 RampUpTester test(1, 0, 0, RtpExtension::kTransportSequenceNumberUri, false,
544 false);
545 RunBaseTest(&test);
546 }
547
TEST_F(RampUpTest,TransportSequenceNumberSimulcast)548 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
549 RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumberUri, false,
550 false);
551 RunBaseTest(&test);
552 }
553
TEST_F(RampUpTest,TransportSequenceNumberSimulcastRedRtx)554 TEST_F(RampUpTest, TransportSequenceNumberSimulcastRedRtx) {
555 RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumberUri, true,
556 true);
557 RunBaseTest(&test);
558 }
559 } // namespace webrtc
560