OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 11 matching lines...) Expand all Loading... |
22 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" | 22 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" |
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" | 23 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" |
24 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" | 24 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
25 #include "webrtc/system_wrappers/interface/thread_wrapper.h" | 25 #include "webrtc/system_wrappers/interface/thread_wrapper.h" |
26 #include "webrtc/test/testsupport/perf_test.h" | 26 #include "webrtc/test/testsupport/perf_test.h" |
27 #include "webrtc/video/rampup_tests.h" | 27 #include "webrtc/video/rampup_tests.h" |
28 | 28 |
29 namespace webrtc { | 29 namespace webrtc { |
30 namespace { | 30 namespace { |
31 | 31 |
32 static const int kMaxPacketSize = 1500; | 32 static const int64_t kPollIntervalMs = 250; |
33 const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000; | |
34 | 33 |
35 std::vector<uint32_t> GenerateSsrcs(size_t num_streams, | 34 std::vector<uint32_t> GenerateSsrcs(size_t num_streams, |
36 uint32_t ssrc_offset) { | 35 uint32_t ssrc_offset) { |
37 std::vector<uint32_t> ssrcs; | 36 std::vector<uint32_t> ssrcs; |
38 for (size_t i = 0; i != num_streams; ++i) | 37 for (size_t i = 0; i != num_streams; ++i) |
39 ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i)); | 38 ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i)); |
40 return ssrcs; | 39 return ssrcs; |
41 } | 40 } |
42 } // namespace | 41 } // namespace |
43 | 42 |
44 StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs, | 43 RampUpTester::RampUpTester(size_t num_streams, |
45 newapi::Transport* feedback_transport, | 44 unsigned int start_bitrate_bps, |
46 Clock* clock) | 45 const std::string& extension_type, |
47 : clock_(clock), | 46 bool rtx, |
48 test_done_(EventWrapper::Create()), | 47 bool red) |
49 rtp_parser_(RtpHeaderParser::Create()), | 48 : EndToEndTest(test::CallTest::kLongTimeoutMs), |
50 feedback_transport_(feedback_transport), | 49 event_(false, false), |
51 receive_stats_(ReceiveStatistics::Create(clock)), | 50 clock_(Clock::GetRealTimeClock()), |
52 payload_registry_( | 51 num_streams_(num_streams), |
53 new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))), | 52 rtx_(rtx), |
54 remote_bitrate_estimator_(nullptr), | 53 red_(red), |
| 54 send_stream_(nullptr), |
| 55 start_bitrate_bps_(start_bitrate_bps), |
| 56 start_bitrate_verified_(false), |
55 expected_bitrate_bps_(0), | 57 expected_bitrate_bps_(0), |
56 start_bitrate_bps_(0), | |
57 rtx_media_ssrcs_(rtx_media_ssrcs), | |
58 total_sent_(0), | |
59 padding_sent_(0), | |
60 rtx_media_sent_(0), | |
61 total_packets_sent_(0), | |
62 padding_packets_sent_(0), | |
63 rtx_media_packets_sent_(0), | |
64 test_start_ms_(clock_->TimeInMilliseconds()), | 58 test_start_ms_(clock_->TimeInMilliseconds()), |
65 ramp_up_finished_ms_(0) { | 59 ramp_up_finished_ms_(-1), |
66 // Ideally we would only have to instantiate an RtcpSender, an | 60 extension_type_(extension_type), |
67 // RtpHeaderParser and a RemoteBitrateEstimator here, but due to the current | 61 ssrcs_(GenerateSsrcs(num_streams, 100)), |
68 // state of the RTP module we need a full module and receive statistics to | 62 rtx_ssrcs_(GenerateSsrcs(num_streams, 200)), |
69 // be able to produce an RTCP with REMB. | 63 poller_thread_(ThreadWrapper::CreateThread(&BitrateStatsPollingThread, |
70 RtpRtcp::Configuration config; | 64 this, |
71 config.receive_statistics = receive_stats_.get(); | 65 "BitrateStatsPollingThread")), |
72 feedback_transport_.Enable(); | 66 sender_call_(nullptr) { |
73 config.outgoing_transport = &feedback_transport_; | 67 if (rtx_) { |
74 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config)); | 68 for (size_t i = 0; i < ssrcs_.size(); ++i) |
75 rtp_rtcp_->SetREMBStatus(true); | 69 rtx_ssrc_map_[rtx_ssrcs_[i]] = ssrcs_[i]; |
76 rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound); | 70 } |
77 packet_router_.reset(new PacketRouter()); | 71 poller_thread_->Start(); |
78 packet_router_->AddRtpModule(rtp_rtcp_.get()); | 72 } |
79 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | 73 |
80 kAbsSendTimeExtensionId); | 74 RampUpTester::~RampUpTester() { |
81 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset, | 75 event_.Set(); |
82 kTransmissionTimeOffsetExtensionId); | 76 poller_thread_->Stop(); |
83 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber, | 77 } |
84 kTransportSequenceNumberExtensionId); | 78 |
85 payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType, | 79 Call::Config RampUpTester::GetSenderCallConfig() { |
86 RampUpTest::kFakeSendPayloadType); | 80 Call::Config call_config; |
87 } | |
88 | |
89 StreamObserver::~StreamObserver() { | |
90 packet_router_->RemoveRtpModule(rtp_rtcp_.get()); | |
91 } | |
92 | |
93 void StreamObserver::set_expected_bitrate_bps( | |
94 unsigned int expected_bitrate_bps) { | |
95 rtc::CritScope lock(&crit_); | |
96 expected_bitrate_bps_ = expected_bitrate_bps; | |
97 } | |
98 | |
99 void StreamObserver::set_start_bitrate_bps(unsigned int start_bitrate_bps) { | |
100 rtc::CritScope lock(&crit_); | |
101 start_bitrate_bps_ = start_bitrate_bps; | |
102 } | |
103 | |
104 void StreamObserver::OnReceiveBitrateChanged( | |
105 const std::vector<unsigned int>& ssrcs, unsigned int bitrate) { | |
106 rtc::CritScope lock(&crit_); | |
107 RTC_DCHECK_GT(expected_bitrate_bps_, 0u); | |
108 if (start_bitrate_bps_ != 0) { | 81 if (start_bitrate_bps_ != 0) { |
109 // For tests with an explicitly set start bitrate, verify the first | 82 call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps_; |
110 // bitrate estimate is close to the start bitrate and lower than the | 83 } |
111 // test target bitrate. This is to verify a call respects the configured | 84 call_config.bitrate_config.min_bitrate_bps = 10000; |
112 // start bitrate, but due to the BWE implementation we can't guarantee the | 85 return call_config; |
113 // first estimate really is as high as the start bitrate. | 86 } |
114 EXPECT_GT(bitrate, 0.9 * start_bitrate_bps_); | 87 |
115 start_bitrate_bps_ = 0; | 88 void RampUpTester::OnStreamsCreated( |
116 } | 89 VideoSendStream* send_stream, |
117 if (bitrate >= expected_bitrate_bps_) { | 90 const std::vector<VideoReceiveStream*>& receive_streams) { |
118 ramp_up_finished_ms_ = clock_->TimeInMilliseconds(); | 91 send_stream_ = send_stream; |
119 // Just trigger if there was any rtx padding packet. | 92 } |
120 if (rtx_media_ssrcs_.empty() || rtx_media_sent_ > 0) { | 93 |
121 TriggerTestDone(); | 94 size_t RampUpTester::GetNumStreams() const { |
122 } | 95 return num_streams_; |
123 } | 96 } |
124 rtp_rtcp_->SetREMBData(bitrate, ssrcs); | 97 |
125 rtp_rtcp_->Process(); | 98 void RampUpTester::ModifyConfigs( |
126 } | 99 VideoSendStream::Config* send_config, |
127 | 100 std::vector<VideoReceiveStream::Config>* receive_configs, |
128 bool StreamObserver::SendRtp(const uint8_t* packet, size_t length) { | 101 VideoEncoderConfig* encoder_config) { |
129 rtc::CritScope lock(&crit_); | 102 send_config->suspend_below_min_bitrate = true; |
130 RTPHeader header; | 103 |
131 EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); | 104 if (num_streams_ == 1) { |
132 receive_stats_->IncomingPacket(header, length, false); | 105 encoder_config->streams[0].target_bitrate_bps = |
133 payload_registry_->SetIncomingPayloadType(header); | 106 encoder_config->streams[0].max_bitrate_bps = 2000000; |
134 RTC_DCHECK(remote_bitrate_estimator_ != nullptr); | 107 // For single stream rampup until 1mbps |
135 remote_bitrate_estimator_->IncomingPacket( | 108 expected_bitrate_bps_ = kSingleStreamTargetBps; |
136 clock_->TimeInMilliseconds(), length - header.headerLength, header, true); | |
137 if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) { | |
138 remote_bitrate_estimator_->Process(); | |
139 rtp_rtcp_->Process(); | |
140 } | |
141 total_sent_ += length; | |
142 padding_sent_ += header.paddingLength; | |
143 ++total_packets_sent_; | |
144 if (header.paddingLength > 0) | |
145 ++padding_packets_sent_; | |
146 // Handle RTX retransmission, but only for non-padding-only packets. | |
147 if (rtx_media_ssrcs_.find(header.ssrc) != rtx_media_ssrcs_.end() && | |
148 header.headerLength + header.paddingLength != length) { | |
149 rtx_media_sent_ += length - header.headerLength - header.paddingLength; | |
150 if (header.paddingLength == 0) | |
151 ++rtx_media_packets_sent_; | |
152 uint8_t restored_packet[kMaxPacketSize]; | |
153 uint8_t* restored_packet_ptr = restored_packet; | |
154 size_t restored_length = length; | |
155 EXPECT_TRUE(payload_registry_->RestoreOriginalPacket( | |
156 &restored_packet_ptr, packet, &restored_length, | |
157 rtx_media_ssrcs_[header.ssrc], header)); | |
158 EXPECT_TRUE( | |
159 rtp_parser_->Parse(restored_packet_ptr, restored_length, &header)); | |
160 } else { | 109 } else { |
161 rtp_rtcp_->SetRemoteSSRC(header.ssrc); | 110 // For multi stream rampup until all streams are being sent. That means |
162 } | 111 // enough birate to send all the target streams plus the min bitrate of |
163 return true; | 112 // the last one. |
164 } | 113 expected_bitrate_bps_ = encoder_config->streams.back().min_bitrate_bps; |
165 | 114 for (size_t i = 0; i < encoder_config->streams.size() - 1; ++i) { |
166 bool StreamObserver::SendRtcp(const uint8_t* packet, size_t length) { | 115 expected_bitrate_bps_ += encoder_config->streams[i].target_bitrate_bps; |
167 return true; | 116 } |
168 } | 117 } |
169 | 118 |
170 EventTypeWrapper StreamObserver::Wait() { | 119 send_config->rtp.extensions.clear(); |
171 return test_done_->Wait(test::CallTest::kLongTimeoutMs); | 120 |
172 } | 121 bool remb; |
173 | 122 if (extension_type_ == RtpExtension::kAbsSendTime) { |
174 void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) { | 123 remb = true; |
175 remote_bitrate_estimator_.reset(rbe); | 124 send_config->rtp.extensions.push_back( |
176 } | 125 RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId)); |
177 | 126 } else if (extension_type_ == RtpExtension::kTransportSequenceNumber) { |
178 PacketRouter* StreamObserver::GetPacketRouter() { | 127 remb = false; |
179 return packet_router_.get(); | 128 send_config->rtp.extensions.push_back(RtpExtension( |
180 } | 129 extension_type_.c_str(), kTransportSequenceNumberExtensionId)); |
181 | 130 } else { |
182 void StreamObserver::ReportResult(const std::string& measurement, | 131 remb = true; |
183 size_t value, | 132 send_config->rtp.extensions.push_back(RtpExtension( |
184 const std::string& units) { | 133 extension_type_.c_str(), kTransmissionTimeOffsetExtensionId)); |
| 134 } |
| 135 |
| 136 send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs; |
| 137 send_config->rtp.ssrcs = ssrcs_; |
| 138 if (rtx_) { |
| 139 send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType; |
| 140 send_config->rtp.rtx.ssrcs = rtx_ssrcs_; |
| 141 } |
| 142 if (red_) { |
| 143 send_config->rtp.fec.ulpfec_payload_type = |
| 144 test::CallTest::kUlpfecPayloadType; |
| 145 send_config->rtp.fec.red_payload_type = test::CallTest::kRedPayloadType; |
| 146 } |
| 147 |
| 148 size_t i = 0; |
| 149 for (VideoReceiveStream::Config& recv_config : *receive_configs) { |
| 150 recv_config.rtp.remb = remb; |
| 151 recv_config.rtp.extensions = send_config->rtp.extensions; |
| 152 |
| 153 recv_config.rtp.remote_ssrc = ssrcs_[i]; |
| 154 recv_config.rtp.nack.rtp_history_ms = send_config->rtp.nack.rtp_history_ms; |
| 155 |
| 156 if (red_) { |
| 157 recv_config.rtp.fec.red_payload_type = |
| 158 send_config->rtp.fec.red_payload_type; |
| 159 recv_config.rtp.fec.ulpfec_payload_type = |
| 160 send_config->rtp.fec.ulpfec_payload_type; |
| 161 } |
| 162 |
| 163 if (rtx_) { |
| 164 recv_config.rtp.rtx[send_config->encoder_settings.payload_type].ssrc = |
| 165 rtx_ssrcs_[i]; |
| 166 recv_config.rtp.rtx[send_config->encoder_settings.payload_type] |
| 167 .payload_type = send_config->rtp.rtx.payload_type; |
| 168 } |
| 169 ++i; |
| 170 } |
| 171 } |
| 172 |
| 173 void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) { |
| 174 sender_call_ = sender_call; |
| 175 } |
| 176 |
| 177 bool RampUpTester::BitrateStatsPollingThread(void* obj) { |
| 178 return static_cast<RampUpTester*>(obj)->PollStats(); |
| 179 } |
| 180 |
| 181 bool RampUpTester::PollStats() { |
| 182 if (sender_call_) { |
| 183 Call::Stats stats = sender_call_->GetStats(); |
| 184 |
| 185 RTC_DCHECK_GT(expected_bitrate_bps_, 0); |
| 186 if (!start_bitrate_verified_ && start_bitrate_bps_ != 0) { |
| 187 // For tests with an explicitly set start bitrate, verify the first |
| 188 // bitrate estimate is close to the start bitrate and lower than the |
| 189 // test target bitrate. This is to verify a call respects the configured |
| 190 // start bitrate, but due to the BWE implementation we can't guarantee the |
| 191 // first estimate really is as high as the start bitrate. |
| 192 EXPECT_GT(stats.send_bandwidth_bps, 0.9 * start_bitrate_bps_); |
| 193 start_bitrate_verified_ = true; |
| 194 } |
| 195 if (stats.send_bandwidth_bps >= expected_bitrate_bps_) { |
| 196 ramp_up_finished_ms_ = clock_->TimeInMilliseconds(); |
| 197 observation_complete_->Set(); |
| 198 } |
| 199 } |
| 200 |
| 201 return !event_.Wait(kPollIntervalMs); |
| 202 } |
| 203 |
| 204 void RampUpTester::ReportResult(const std::string& measurement, |
| 205 size_t value, |
| 206 const std::string& units) const { |
185 webrtc::test::PrintResult( | 207 webrtc::test::PrintResult( |
186 measurement, "", | 208 measurement, "", |
187 ::testing::UnitTest::GetInstance()->current_test_info()->name(), | 209 ::testing::UnitTest::GetInstance()->current_test_info()->name(), |
188 value, units, false); | 210 value, units, false); |
189 } | 211 } |
190 | 212 |
191 void StreamObserver::TriggerTestDone() EXCLUSIVE_LOCKS_REQUIRED(crit_) { | 213 void RampUpTester::GetStats(const VideoSendStream::StreamStats& stream, |
192 ReportResult("ramp-up-total-sent", total_sent_, "bytes"); | 214 size_t* total_packets_sent, |
193 ReportResult("ramp-up-padding-sent", padding_sent_, "bytes"); | 215 size_t* total_sent, |
194 ReportResult("ramp-up-rtx-media-sent", rtx_media_sent_, "bytes"); | 216 size_t* padding_sent, |
195 ReportResult("ramp-up-total-packets-sent", total_packets_sent_, "packets"); | 217 size_t* media_sent) const { |
196 ReportResult("ramp-up-padding-packets-sent", | 218 *total_packets_sent += stream.rtp_stats.transmitted.packets + |
197 padding_packets_sent_, | 219 stream.rtp_stats.retransmitted.packets + |
| 220 stream.rtp_stats.fec.packets; |
| 221 *total_sent += stream.rtp_stats.transmitted.TotalBytes() + |
| 222 stream.rtp_stats.retransmitted.TotalBytes() + |
| 223 stream.rtp_stats.fec.TotalBytes(); |
| 224 *padding_sent += stream.rtp_stats.transmitted.padding_bytes + |
| 225 stream.rtp_stats.retransmitted.padding_bytes + |
| 226 stream.rtp_stats.fec.padding_bytes; |
| 227 *media_sent += stream.rtp_stats.MediaPayloadBytes(); |
| 228 } |
| 229 |
| 230 void RampUpTester::TriggerTestDone() { |
| 231 VideoSendStream::Stats send_stats = send_stream_->GetStats(); |
| 232 |
| 233 size_t total_packets_sent = 0; |
| 234 size_t total_sent = 0; |
| 235 size_t padding_sent = 0; |
| 236 size_t media_sent = 0; |
| 237 for (uint32_t ssrc : ssrcs_) { |
| 238 GetStats(send_stats.substreams[ssrc], &total_packets_sent, &total_sent, |
| 239 &padding_sent, &media_sent); |
| 240 } |
| 241 |
| 242 size_t rtx_total_packets_sent = 0; |
| 243 size_t rtx_total_sent = 0; |
| 244 size_t rtx_padding_sent = 0; |
| 245 size_t rtx_media_sent = 0; |
| 246 for (uint32_t rtx_ssrc : rtx_ssrcs_) { |
| 247 GetStats(send_stats.substreams[rtx_ssrc], &total_packets_sent, &total_sent, |
| 248 &padding_sent, &media_sent); |
| 249 } |
| 250 |
| 251 ReportResult("ramp-up-total-packets-sent", total_packets_sent, "packets"); |
| 252 ReportResult("ramp-up-total-sent", total_sent, "bytes"); |
| 253 ReportResult("ramp-up-media-sent", media_sent, "bytes"); |
| 254 ReportResult("ramp-up-padding-sent", padding_sent, "bytes"); |
| 255 ReportResult("ramp-up-rtx-total-packets-sent", rtx_total_packets_sent, |
198 "packets"); | 256 "packets"); |
199 ReportResult("ramp-up-rtx-packets-sent", | 257 ReportResult("ramp-up-rtx-total-sent", rtx_total_sent, "bytes"); |
200 rtx_media_packets_sent_, | 258 ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, "bytes"); |
201 "packets"); | 259 ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, "bytes"); |
202 ReportResult("ramp-up-time", | 260 if (ramp_up_finished_ms_ >= 0) { |
203 ramp_up_finished_ms_ - test_start_ms_, | 261 ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_, |
204 "milliseconds"); | 262 "milliseconds"); |
205 test_done_->Set(); | 263 } |
206 } | 264 } |
207 | 265 |
208 LowRateStreamObserver::LowRateStreamObserver( | 266 void RampUpTester::PerformTest() { |
209 newapi::Transport* feedback_transport, | 267 if (Wait() != kEventSignaled) { |
210 Clock* clock, | 268 printf("Timed out while waiting for ramp-up to complete."); |
211 size_t number_of_streams, | 269 return; |
212 bool rtx_used) | 270 } |
213 : clock_(clock), | 271 TriggerTestDone(); |
214 number_of_streams_(number_of_streams), | 272 } |
215 rtx_used_(rtx_used), | 273 |
216 test_done_(EventWrapper::Create()), | 274 RampUpDownUpTester::RampUpDownUpTester(size_t num_streams, |
217 rtp_parser_(RtpHeaderParser::Create()), | 275 unsigned int start_bitrate_bps, |
218 feedback_transport_(feedback_transport), | 276 const std::string& extension_type, |
219 receive_stats_(ReceiveStatistics::Create(clock)), | 277 bool rtx, |
220 send_stream_(nullptr), | 278 bool red) |
| 279 : RampUpTester(num_streams, start_bitrate_bps, extension_type, rtx, red), |
221 test_state_(kFirstRampup), | 280 test_state_(kFirstRampup), |
222 state_start_ms_(clock_->TimeInMilliseconds()), | 281 state_start_ms_(clock_->TimeInMilliseconds()), |
223 interval_start_ms_(state_start_ms_), | 282 interval_start_ms_(clock_->TimeInMilliseconds()), |
224 last_remb_bps_(0), | 283 sent_bytes_(0) { |
225 sent_bytes_(0), | |
226 total_overuse_bytes_(0), | |
227 suspended_in_stats_(false) { | |
228 RtpRtcp::Configuration config; | |
229 config.receive_statistics = receive_stats_.get(); | |
230 feedback_transport_.Enable(); | |
231 config.outgoing_transport = &feedback_transport_; | |
232 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config)); | |
233 rtp_rtcp_->SetREMBStatus(true); | |
234 rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound); | |
235 rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime, | |
236 kAbsSendTimeExtensionId); | |
237 const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 10000; | |
238 remote_bitrate_estimator_.reset(new RemoteBitrateEstimatorAbsSendTime( | |
239 this, clock, kRemoteBitrateEstimatorMinBitrateBps)); | |
240 forward_transport_config_.link_capacity_kbps = | 284 forward_transport_config_.link_capacity_kbps = |
241 kHighBandwidthLimitBps / 1000; | 285 kHighBandwidthLimitBps / 1000; |
242 forward_transport_config_.queue_length_packets = 100; // Something large. | 286 send_transport_.SetConfig(forward_transport_config_); |
243 test::DirectTransport::SetConfig(forward_transport_config_); | 287 } |
244 test::DirectTransport::SetReceiver(this); | 288 |
245 } | 289 RampUpDownUpTester::~RampUpDownUpTester() {} |
246 | 290 |
247 void LowRateStreamObserver::SetSendStream(VideoSendStream* send_stream) { | 291 bool RampUpDownUpTester::PollStats() { |
248 rtc::CritScope lock(&crit_); | 292 if (send_stream_) { |
249 send_stream_ = send_stream; | 293 webrtc::VideoSendStream::Stats stats = send_stream_->GetStats(); |
250 } | 294 int transmit_bitrate_bps = 0; |
251 | 295 for (auto it : stats.substreams) { |
252 void LowRateStreamObserver::OnReceiveBitrateChanged( | 296 transmit_bitrate_bps += it.second.total_bitrate_bps; |
253 const std::vector<unsigned int>& ssrcs, | 297 } |
254 unsigned int bitrate) { | 298 |
255 rtc::CritScope lock(&crit_); | 299 EvolveTestState(transmit_bitrate_bps, stats.suspended); |
256 rtp_rtcp_->SetREMBData(bitrate, ssrcs); | 300 } |
257 rtp_rtcp_->Process(); | 301 |
258 last_remb_bps_ = bitrate; | 302 return !event_.Wait(kPollIntervalMs); |
259 } | 303 } |
260 | 304 |
261 bool LowRateStreamObserver::SendRtp(const uint8_t* data, size_t length) { | 305 Call::Config RampUpDownUpTester::GetReceiverCallConfig() { |
262 rtc::CritScope lock(&crit_); | 306 Call::Config config; |
263 sent_bytes_ += length; | 307 config.bitrate_config.min_bitrate_bps = 10000; |
264 int64_t now_ms = clock_->TimeInMilliseconds(); | 308 return config; |
265 if (now_ms > interval_start_ms_ + 1000) { // Let at least 1 second pass. | 309 } |
266 // Verify that the send rate was about right. | 310 |
267 unsigned int average_rate_bps = static_cast<unsigned int>(sent_bytes_) * | 311 std::string RampUpDownUpTester::GetModifierString() const { |
268 8 * 1000 / (now_ms - interval_start_ms_); | |
269 // TODO(holmer): Why is this failing? | |
270 // EXPECT_LT(average_rate_bps, last_remb_bps_ * 1.1); | |
271 if (average_rate_bps > last_remb_bps_ * 1.1) { | |
272 total_overuse_bytes_ += | |
273 sent_bytes_ - | |
274 last_remb_bps_ / 8 * (now_ms - interval_start_ms_) / 1000; | |
275 } | |
276 EvolveTestState(average_rate_bps); | |
277 interval_start_ms_ = now_ms; | |
278 sent_bytes_ = 0; | |
279 } | |
280 return test::DirectTransport::SendRtp(data, length); | |
281 } | |
282 | |
283 PacketReceiver::DeliveryStatus LowRateStreamObserver::DeliverPacket( | |
284 MediaType media_type, | |
285 const uint8_t* packet, | |
286 size_t length, | |
287 const PacketTime& packet_time) { | |
288 rtc::CritScope lock(&crit_); | |
289 RTPHeader header; | |
290 EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); | |
291 receive_stats_->IncomingPacket(header, length, false); | |
292 remote_bitrate_estimator_->IncomingPacket( | |
293 clock_->TimeInMilliseconds(), length - header.headerLength, header, true); | |
294 if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) { | |
295 remote_bitrate_estimator_->Process(); | |
296 } | |
297 suspended_in_stats_ = send_stream_->GetStats().suspended; | |
298 return DELIVERY_OK; | |
299 } | |
300 | |
301 bool LowRateStreamObserver::SendRtcp(const uint8_t* packet, size_t length) { | |
302 return true; | |
303 } | |
304 | |
305 std::string LowRateStreamObserver::GetModifierString() { | |
306 std::string str("_"); | 312 std::string str("_"); |
307 char temp_str[5]; | 313 char temp_str[5]; |
308 sprintf(temp_str, "%i", | 314 sprintf(temp_str, "%i", static_cast<int>(num_streams_)); |
309 static_cast<int>(number_of_streams_)); | |
310 str += std::string(temp_str); | 315 str += std::string(temp_str); |
311 str += "stream"; | 316 str += "stream"; |
312 str += (number_of_streams_ > 1 ? "s" : ""); | 317 str += (num_streams_ > 1 ? "s" : ""); |
313 str += "_"; | 318 str += "_"; |
314 str += (rtx_used_ ? "" : "no"); | 319 str += (rtx_ ? "" : "no"); |
315 str += "rtx"; | 320 str += "rtx"; |
316 return str; | 321 return str; |
317 } | 322 } |
318 | 323 |
319 void LowRateStreamObserver::EvolveTestState(unsigned int bitrate_bps) { | 324 void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) { |
320 int64_t now = clock_->TimeInMilliseconds(); | 325 int64_t now = clock_->TimeInMilliseconds(); |
321 rtc::CritScope lock(&crit_); | |
322 RTC_DCHECK(send_stream_ != nullptr); | |
323 switch (test_state_) { | 326 switch (test_state_) { |
324 case kFirstRampup: { | 327 case kFirstRampup: { |
325 EXPECT_FALSE(suspended_in_stats_); | 328 EXPECT_FALSE(suspended); |
326 if (bitrate_bps > kExpectedHighBitrateBps) { | 329 if (bitrate_bps > kExpectedHighBitrateBps) { |
327 // The first ramp-up has reached the target bitrate. Change the | 330 // The first ramp-up has reached the target bitrate. Change the |
328 // channel limit, and move to the next test state. | 331 // channel limit, and move to the next test state. |
329 forward_transport_config_.link_capacity_kbps = | 332 forward_transport_config_.link_capacity_kbps = |
330 kLowBandwidthLimitBps / 1000; | 333 kLowBandwidthLimitBps / 1000; |
331 test::DirectTransport::SetConfig(forward_transport_config_); | 334 send_transport_.SetConfig(forward_transport_config_); |
332 test_state_ = kLowRate; | 335 test_state_ = kLowRate; |
333 webrtc::test::PrintResult("ramp_up_down_up", | 336 webrtc::test::PrintResult("ramp_up_down_up", |
334 GetModifierString(), | 337 GetModifierString(), |
335 "first_rampup", | 338 "first_rampup", |
336 now - state_start_ms_, | 339 now - state_start_ms_, |
337 "ms", | 340 "ms", |
338 false); | 341 false); |
339 state_start_ms_ = now; | 342 state_start_ms_ = now; |
340 interval_start_ms_ = now; | 343 interval_start_ms_ = now; |
341 sent_bytes_ = 0; | 344 sent_bytes_ = 0; |
342 } | 345 } |
343 break; | 346 break; |
344 } | 347 } |
345 case kLowRate: { | 348 case kLowRate: { |
346 if (bitrate_bps < kExpectedLowBitrateBps && suspended_in_stats_) { | 349 if (bitrate_bps < kExpectedLowBitrateBps && suspended) { |
347 // The ramp-down was successful. Change the channel limit back to a | 350 // The ramp-down was successful. Change the channel limit back to a |
348 // high value, and move to the next test state. | 351 // high value, and move to the next test state. |
349 forward_transport_config_.link_capacity_kbps = | 352 forward_transport_config_.link_capacity_kbps = |
350 kHighBandwidthLimitBps / 1000; | 353 kHighBandwidthLimitBps / 1000; |
351 test::DirectTransport::SetConfig(forward_transport_config_); | 354 send_transport_.SetConfig(forward_transport_config_); |
352 test_state_ = kSecondRampup; | 355 test_state_ = kSecondRampup; |
353 webrtc::test::PrintResult("ramp_up_down_up", | 356 webrtc::test::PrintResult("ramp_up_down_up", |
354 GetModifierString(), | 357 GetModifierString(), |
355 "rampdown", | 358 "rampdown", |
356 now - state_start_ms_, | 359 now - state_start_ms_, |
357 "ms", | 360 "ms", |
358 false); | 361 false); |
359 state_start_ms_ = now; | 362 state_start_ms_ = now; |
360 interval_start_ms_ = now; | 363 interval_start_ms_ = now; |
361 sent_bytes_ = 0; | 364 sent_bytes_ = 0; |
362 } | 365 } |
363 break; | 366 break; |
364 } | 367 } |
365 case kSecondRampup: { | 368 case kSecondRampup: { |
366 if (bitrate_bps > kExpectedHighBitrateBps && !suspended_in_stats_) { | 369 if (bitrate_bps > kExpectedHighBitrateBps && !suspended) { |
367 webrtc::test::PrintResult("ramp_up_down_up", | 370 webrtc::test::PrintResult("ramp_up_down_up", |
368 GetModifierString(), | 371 GetModifierString(), |
369 "second_rampup", | 372 "second_rampup", |
370 now - state_start_ms_, | 373 now - state_start_ms_, |
371 "ms", | 374 "ms", |
372 false); | 375 false); |
373 webrtc::test::PrintResult("ramp_up_down_up", | 376 observation_complete_->Set(); |
374 GetModifierString(), | |
375 "total_overuse", | |
376 total_overuse_bytes_, | |
377 "bytes", | |
378 false); | |
379 test_done_->Set(); | |
380 } | 377 } |
381 break; | 378 break; |
382 } | 379 } |
383 } | 380 } |
384 } | 381 } |
385 | 382 |
386 EventTypeWrapper LowRateStreamObserver::Wait() { | 383 class RampUpTest : public test::CallTest { |
387 return test_done_->Wait(test::CallTest::kLongTimeoutMs); | 384 public: |
388 } | 385 RampUpTest() {} |
389 | 386 |
390 class SendBitrateAdapter { | 387 virtual ~RampUpTest() { |
391 public: | 388 EXPECT_EQ(nullptr, send_stream_); |
392 static const int64_t kPollIntervalMs = 250; | 389 EXPECT_TRUE(receive_streams_.empty()); |
393 | |
394 SendBitrateAdapter(const Call& call, | |
395 const std::vector<uint32_t>& ssrcs, | |
396 RemoteBitrateObserver* bitrate_observer) | |
397 : event_(false, false), | |
398 call_(call), | |
399 ssrcs_(ssrcs), | |
400 bitrate_observer_(bitrate_observer) { | |
401 RTC_DCHECK(bitrate_observer != nullptr); | |
402 poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread, | |
403 this, "SendBitratePoller"); | |
404 bool thread_start_ok = poller_thread_->Start(); | |
405 RTC_DCHECK(thread_start_ok); | |
406 } | 390 } |
407 | |
408 virtual ~SendBitrateAdapter() { | |
409 event_.Set(); | |
410 poller_thread_->Stop(); | |
411 } | |
412 | |
413 private: | |
414 static bool SendBitrateAdapterThread(void* obj) { | |
415 return static_cast<SendBitrateAdapter*>(obj)->PollStats(); | |
416 } | |
417 | |
418 bool PollStats() { | |
419 Call::Stats stats = call_.GetStats(); | |
420 | |
421 bitrate_observer_->OnReceiveBitrateChanged(ssrcs_, | |
422 stats.send_bandwidth_bps); | |
423 return !event_.Wait(kPollIntervalMs); | |
424 } | |
425 | |
426 rtc::Event event_; | |
427 rtc::scoped_ptr<ThreadWrapper> poller_thread_; | |
428 const Call& call_; | |
429 const std::vector<uint32_t> ssrcs_; | |
430 RemoteBitrateObserver* const bitrate_observer_; | |
431 }; | 391 }; |
432 | 392 |
433 void RampUpTest::RunRampUpTest(size_t num_streams, | |
434 unsigned int start_bitrate_bps, | |
435 const std::string& extension_type, | |
436 bool rtx, | |
437 bool red) { | |
438 std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100)); | |
439 std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200)); | |
440 StreamObserver::SsrcMap rtx_ssrc_map; | |
441 if (rtx) { | |
442 for (size_t i = 0; i < ssrcs.size(); ++i) | |
443 rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i]; | |
444 } | |
445 | |
446 test::DirectTransport receiver_transport; | |
447 StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport, | |
448 Clock::GetRealTimeClock()); | |
449 | |
450 CreateSendConfig(num_streams, &stream_observer); | |
451 send_config_.rtp.extensions.clear(); | |
452 | |
453 rtc::scoped_ptr<SendBitrateAdapter> send_bitrate_adapter_; | |
454 | |
455 if (extension_type == RtpExtension::kAbsSendTime) { | |
456 stream_observer.SetRemoteBitrateEstimator( | |
457 new RemoteBitrateEstimatorAbsSendTime( | |
458 &stream_observer, Clock::GetRealTimeClock(), | |
459 kRemoteBitrateEstimatorMinBitrateBps)); | |
460 send_config_.rtp.extensions.push_back(RtpExtension( | |
461 extension_type.c_str(), kAbsSendTimeExtensionId)); | |
462 } else if (extension_type == RtpExtension::kTransportSequenceNumber) { | |
463 stream_observer.SetRemoteBitrateEstimator(new RemoteEstimatorProxy( | |
464 Clock::GetRealTimeClock(), stream_observer.GetPacketRouter())); | |
465 send_config_.rtp.extensions.push_back(RtpExtension( | |
466 extension_type.c_str(), kTransportSequenceNumberExtensionId)); | |
467 } else { | |
468 stream_observer.SetRemoteBitrateEstimator( | |
469 new RemoteBitrateEstimatorSingleStream( | |
470 &stream_observer, Clock::GetRealTimeClock(), | |
471 kRemoteBitrateEstimatorMinBitrateBps)); | |
472 send_config_.rtp.extensions.push_back(RtpExtension( | |
473 extension_type.c_str(), kTransmissionTimeOffsetExtensionId)); | |
474 } | |
475 | |
476 Call::Config call_config; | |
477 if (start_bitrate_bps != 0) { | |
478 call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps; | |
479 stream_observer.set_start_bitrate_bps(start_bitrate_bps); | |
480 } | |
481 CreateSenderCall(call_config); | |
482 | |
483 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
484 | |
485 if (num_streams == 1) { | |
486 encoder_config_.streams[0].target_bitrate_bps = 2000000; | |
487 encoder_config_.streams[0].max_bitrate_bps = 2000000; | |
488 } | |
489 | |
490 send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | |
491 send_config_.rtp.ssrcs = ssrcs; | |
492 if (rtx) { | |
493 send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | |
494 send_config_.rtp.rtx.ssrcs = rtx_ssrcs; | |
495 } | |
496 if (red) { | |
497 send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; | |
498 send_config_.rtp.fec.red_payload_type = kRedPayloadType; | |
499 } | |
500 | |
501 if (num_streams == 1) { | |
502 // For single stream rampup until 1mbps | |
503 stream_observer.set_expected_bitrate_bps(kSingleStreamTargetBps); | |
504 } else { | |
505 // For multi stream rampup until all streams are being sent. That means | |
506 // enough birate to send all the target streams plus the min bitrate of | |
507 // the last one. | |
508 int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps; | |
509 for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) { | |
510 expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps; | |
511 } | |
512 stream_observer.set_expected_bitrate_bps(expected_bitrate_bps); | |
513 } | |
514 | |
515 CreateStreams(); | |
516 CreateFrameGeneratorCapturer(); | |
517 | |
518 if (extension_type == RtpExtension::kTransportSequenceNumber) { | |
519 send_bitrate_adapter_.reset( | |
520 new SendBitrateAdapter(*sender_call_.get(), ssrcs, &stream_observer)); | |
521 } | |
522 Start(); | |
523 | |
524 EXPECT_EQ(kEventSignaled, stream_observer.Wait()); | |
525 | |
526 // Destroy the SendBitrateAdapter (if any) to stop the poller thread in it, | |
527 // otherwise we might get a data race with the destruction of the call. | |
528 send_bitrate_adapter_.reset(); | |
529 | |
530 Stop(); | |
531 DestroyStreams(); | |
532 } | |
533 | |
534 void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams, | |
535 bool rtx, | |
536 bool red) { | |
537 test::DirectTransport receiver_transport; | |
538 LowRateStreamObserver stream_observer( | |
539 &receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx); | |
540 | |
541 Call::Config call_config; | |
542 call_config.bitrate_config.start_bitrate_bps = 60000; | |
543 CreateSenderCall(call_config); | |
544 receiver_transport.SetReceiver(sender_call_->Receiver()); | |
545 | |
546 CreateSendConfig(number_of_streams, &stream_observer); | |
547 | |
548 send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs; | |
549 send_config_.rtp.extensions.push_back(RtpExtension( | |
550 RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); | |
551 send_config_.suspend_below_min_bitrate = true; | |
552 | |
553 if (rtx) { | |
554 send_config_.rtp.rtx.payload_type = kSendRtxPayloadType; | |
555 send_config_.rtp.rtx.ssrcs = GenerateSsrcs(number_of_streams, 200); | |
556 } | |
557 if (red) { | |
558 send_config_.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType; | |
559 send_config_.rtp.fec.red_payload_type = kRedPayloadType; | |
560 } | |
561 | |
562 CreateStreams(); | |
563 stream_observer.SetSendStream(send_stream_); | |
564 | |
565 CreateFrameGeneratorCapturer(); | |
566 | |
567 Start(); | |
568 | |
569 EXPECT_EQ(kEventSignaled, stream_observer.Wait()); | |
570 | |
571 Stop(); | |
572 DestroyStreams(); | |
573 } | |
574 | |
575 TEST_F(RampUpTest, SingleStream) { | 393 TEST_F(RampUpTest, SingleStream) { |
576 RunRampUpTest(1, 0, RtpExtension::kTOffset, false, false); | 394 RampUpTester test(1, 0, RtpExtension::kTOffset, false, false); |
| 395 RunBaseTest(&test); |
577 } | 396 } |
578 | 397 |
579 TEST_F(RampUpTest, Simulcast) { | 398 TEST_F(RampUpTest, Simulcast) { |
580 RunRampUpTest(3, 0, RtpExtension::kTOffset, false, false); | 399 RampUpTester test(3, 0, RtpExtension::kTOffset, false, false); |
| 400 RunBaseTest(&test); |
581 } | 401 } |
582 | 402 |
583 TEST_F(RampUpTest, SimulcastWithRtx) { | 403 TEST_F(RampUpTest, SimulcastWithRtx) { |
584 RunRampUpTest(3, 0, RtpExtension::kTOffset, true, false); | 404 RampUpTester test(3, 0, RtpExtension::kTOffset, true, false); |
| 405 RunBaseTest(&test); |
585 } | 406 } |
586 | 407 |
587 TEST_F(RampUpTest, SimulcastByRedWithRtx) { | 408 TEST_F(RampUpTest, SimulcastByRedWithRtx) { |
588 RunRampUpTest(3, 0, RtpExtension::kTOffset, true, true); | 409 RampUpTester test(3, 0, RtpExtension::kTOffset, true, true); |
| 410 RunBaseTest(&test); |
589 } | 411 } |
590 | 412 |
591 TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) { | 413 TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) { |
592 RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset, false, | 414 RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset, |
593 false); | 415 false, false); |
| 416 RunBaseTest(&test); |
594 } | 417 } |
595 | 418 |
596 TEST_F(RampUpTest, UpDownUpOneStream) { | 419 TEST_F(RampUpTest, UpDownUpOneStream) { |
597 RunRampUpDownUpTest(1, false, false); | 420 RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, false, false); |
| 421 RunBaseTest(&test); |
598 } | 422 } |
599 | 423 |
600 TEST_F(RampUpTest, UpDownUpThreeStreams) { | 424 TEST_F(RampUpTest, UpDownUpThreeStreams) { |
601 RunRampUpDownUpTest(3, false, false); | 425 RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, false, false); |
| 426 RunBaseTest(&test); |
602 } | 427 } |
603 | 428 |
604 TEST_F(RampUpTest, UpDownUpOneStreamRtx) { | 429 TEST_F(RampUpTest, UpDownUpOneStreamRtx) { |
605 RunRampUpDownUpTest(1, true, false); | 430 RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, false); |
| 431 RunBaseTest(&test); |
606 } | 432 } |
607 | 433 |
608 TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) { | 434 TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) { |
609 RunRampUpDownUpTest(3, true, false); | 435 RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, false); |
| 436 RunBaseTest(&test); |
610 } | 437 } |
611 | 438 |
612 TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) { | 439 TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) { |
613 RunRampUpDownUpTest(1, true, true); | 440 RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, true); |
| 441 RunBaseTest(&test); |
614 } | 442 } |
615 | 443 |
616 TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) { | 444 TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) { |
617 RunRampUpDownUpTest(3, true, true); | 445 RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, true); |
| 446 RunBaseTest(&test); |
618 } | 447 } |
619 | 448 |
620 TEST_F(RampUpTest, AbsSendTimeSingleStream) { | 449 TEST_F(RampUpTest, AbsSendTimeSingleStream) { |
621 RunRampUpTest(1, 0, RtpExtension::kAbsSendTime, false, false); | 450 RampUpTester test(1, 0, RtpExtension::kAbsSendTime, false, false); |
| 451 RunBaseTest(&test); |
622 } | 452 } |
623 | 453 |
624 TEST_F(RampUpTest, AbsSendTimeSimulcast) { | 454 TEST_F(RampUpTest, AbsSendTimeSimulcast) { |
625 RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, false, false); | 455 RampUpTester test(3, 0, RtpExtension::kAbsSendTime, false, false); |
| 456 RunBaseTest(&test); |
626 } | 457 } |
627 | 458 |
628 TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) { | 459 TEST_F(RampUpTest, AbsSendTimeSimulcastWithRtx) { |
629 RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, true, false); | 460 RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, false); |
| 461 RunBaseTest(&test); |
630 } | 462 } |
631 | 463 |
632 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) { | 464 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) { |
633 RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, true, true); | 465 RampUpTester test(3, 0, RtpExtension::kAbsSendTime, true, true); |
| 466 RunBaseTest(&test); |
634 } | 467 } |
635 | 468 |
636 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) { | 469 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) { |
637 RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime, | 470 RampUpTester test(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime, |
638 false, false); | 471 false, false); |
| 472 RunBaseTest(&test); |
639 } | 473 } |
640 | 474 |
641 TEST_F(RampUpTest, TransportSequenceNumberSingleStream) { | 475 TEST_F(RampUpTest, TransportSequenceNumberSingleStream) { |
642 RunRampUpTest(1, 0, RtpExtension::kTransportSequenceNumber, false, false); | 476 RampUpTester test(1, 0, RtpExtension::kTransportSequenceNumber, false, false); |
| 477 RunBaseTest(&test); |
643 } | 478 } |
644 | 479 |
645 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) { | 480 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) { |
646 RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, false, false); | 481 RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, false, false); |
| 482 RunBaseTest(&test); |
647 } | 483 } |
648 | 484 |
649 TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) { | 485 TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) { |
650 RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, false); | 486 RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, false); |
| 487 RunBaseTest(&test); |
651 } | 488 } |
652 | 489 |
653 TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) { | 490 TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) { |
654 RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, true); | 491 RampUpTester test(3, 0, RtpExtension::kTransportSequenceNumber, true, true); |
| 492 RunBaseTest(&test); |
655 } | 493 } |
656 | 494 |
657 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) { | 495 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) { |
658 RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, | 496 RampUpTester test(1, 0.9 * kSingleStreamTargetBps, |
659 RtpExtension::kTransportSequenceNumber, false, false); | 497 RtpExtension::kTransportSequenceNumber, false, false); |
| 498 RunBaseTest(&test); |
660 } | 499 } |
661 } // namespace webrtc | 500 } // namespace webrtc |
OLD | NEW |