pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 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 | */ |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 10 | |
| 11 | #include "testing/gtest/include/gtest/gtest.h" |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 12 | #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h" |
| 13 | #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 14 | #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h" |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 15 | #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.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 18 | #include "webrtc/test/testsupport/perf_test.h" |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 19 | #include "webrtc/video/rampup_tests.h" |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 20 | |
| 21 | namespace webrtc { |
pbos@webrtc.org | 2902328 | 2013-09-11 10:14:56 +0000 | [diff] [blame] | 22 | namespace { |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 23 | |
pbos@webrtc.org | c279a5d | 2014-01-24 09:30:53 +0000 | [diff] [blame] | 24 | static const int kMaxPacketSize = 1500; |
pbos@webrtc.org | 2902328 | 2013-09-11 10:14:56 +0000 | [diff] [blame] | 25 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 26 | std::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.org | eb16b81 | 2014-06-16 08:57:39 +0000 | [diff] [blame] | 33 | } // namespace |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 34 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 35 | StreamObserver::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 | |
| 80 | void 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 | |
| 86 | void StreamObserver::set_start_bitrate_bps(unsigned int start_bitrate_bps) { |
| 87 | CriticalSectionScoped lock(crit_.get()); |
| 88 | start_bitrate_bps_ = start_bitrate_bps; |
| 89 | } |
| 90 | |
| 91 | void 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.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 102 | 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.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 109 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 110 | } |
| 111 | rtp_rtcp_->SetREMBData( |
| 112 | bitrate, static_cast<uint8_t>(ssrcs.size()), &ssrcs[0]); |
| 113 | rtp_rtcp_->Process(); |
| 114 | } |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 115 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 116 | bool 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 | |
| 153 | bool StreamObserver::SendRtcp(const uint8_t* packet, size_t length) { |
| 154 | return true; |
| 155 | } |
| 156 | |
pbos@webrtc.org | 32452b2 | 2014-10-22 12:15:24 +0000 | [diff] [blame^] | 157 | EventTypeWrapper StreamObserver::Wait() { |
| 158 | return test_done_->Wait(test::CallTest::kLongTimeoutMs); |
| 159 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 160 | |
| 161 | void 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 | |
| 170 | void 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 | |
| 187 | LowRateStreamObserver::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.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 224 | forward_transport_config_.queue_length_packets = 100; // Something large. |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 225 | test::DirectTransport::SetConfig(forward_transport_config_); |
| 226 | test::DirectTransport::SetReceiver(this); |
| 227 | } |
| 228 | |
| 229 | void LowRateStreamObserver::SetSendStream(const VideoSendStream* send_stream) { |
| 230 | CriticalSectionScoped lock(crit_.get()); |
| 231 | send_stream_ = send_stream; |
| 232 | } |
| 233 | |
| 234 | void 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 | |
| 244 | bool 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.org | eb16b81 | 2014-06-16 08:57:39 +0000 | [diff] [blame] | 258 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 259 | 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.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 265 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 266 | PacketReceiver::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.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 280 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 281 | bool LowRateStreamObserver::SendRtcp(const uint8_t* packet, size_t length) { |
| 282 | return true; |
| 283 | } |
andresp@webrtc.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 284 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 285 | std::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.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 298 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 299 | void 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.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 322 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 323 | break; |
pbos@webrtc.org | f577ae9 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 324 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 325 | 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.org | f577ae9 | 2014-03-19 08:43:57 +0000 | [diff] [blame] | 365 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 366 | EventTypeWrapper LowRateStreamObserver::Wait() { |
| 367 | return test_done_->Wait(test::CallTest::kLongTimeoutMs); |
| 368 | } |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 369 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 370 | void 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.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 380 | } |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 381 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 382 | CreateSendConfig(num_streams); |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 383 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 384 | 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.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 389 | send_config_.rtp.extensions.push_back(RtpExtension( |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 390 | 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.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 396 | } |
| 397 | |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 398 | 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.org | a73a678 | 2014-10-14 11:52:10 +0000 | [diff] [blame] | 407 | call_config.stream_start_bitrate_bps = start_bitrate_bps; |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 408 | stream_observer.set_start_bitrate_bps(start_bitrate_bps); |
andresp@webrtc.org | a714eaf | 2014-03-17 15:34:57 +0000 | [diff] [blame] | 409 | } |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 410 | |
| 411 | CreateSenderCall(call_config); |
| 412 | |
| 413 | receiver_transport.SetReceiver(sender_call_->Receiver()); |
| 414 | |
| 415 | if (num_streams == 1) { |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 416 | encoder_config_.streams[0].target_bitrate_bps = 2000000; |
| 417 | encoder_config_.streams[0].max_bitrate_bps = 2000000; |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 418 | } |
| 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.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 435 | 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.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 438 | } |
| 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 | |
| 453 | void 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.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 486 | |
stefan@webrtc.org | cb254aa | 2014-06-12 15:12:25 +0000 | [diff] [blame] | 487 | TEST_F(RampUpTest, SingleStream) { |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 488 | RunRampUpTest(false, 1, 0, RtpExtension::kTOffset); |
andresp@webrtc.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 489 | } |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 490 | |
stefan@webrtc.org | cb254aa | 2014-06-12 15:12:25 +0000 | [diff] [blame] | 491 | TEST_F(RampUpTest, Simulcast) { |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 492 | RunRampUpTest(false, 3, 0, RtpExtension::kTOffset); |
andresp@webrtc.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 493 | } |
| 494 | |
stefan@webrtc.org | cb254aa | 2014-06-12 15:12:25 +0000 | [diff] [blame] | 495 | TEST_F(RampUpTest, SimulcastWithRtx) { |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 496 | RunRampUpTest(true, 3, 0, RtpExtension::kTOffset); |
mflodman@webrtc.org | eb16b81 | 2014-06-16 08:57:39 +0000 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) { |
stefan@webrtc.org | 3d7da88 | 2014-07-08 13:59:46 +0000 | [diff] [blame] | 500 | RunRampUpTest(false, 1, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset); |
andresp@webrtc.org | c148079 | 2014-03-20 03:23:55 +0000 | [diff] [blame] | 501 | } |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 502 | |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 503 | TEST_F(RampUpTest, UpDownUpOneStream) { RunRampUpDownUpTest(1, false); } |
| 504 | |
henrik.lundin@webrtc.org | 6ea4f63 | 2014-03-13 09:21:26 +0000 | [diff] [blame] | 505 | TEST_F(RampUpTest, UpDownUpThreeStreams) { RunRampUpDownUpTest(3, false); } |
henrik.lundin@webrtc.org | 998cb8f | 2014-03-06 09:12:00 +0000 | [diff] [blame] | 506 | |
henrik.lundin@webrtc.org | 6ea4f63 | 2014-03-13 09:21:26 +0000 | [diff] [blame] | 507 | TEST_F(RampUpTest, UpDownUpOneStreamRtx) { RunRampUpDownUpTest(1, true); } |
henrik.lundin@webrtc.org | 998cb8f | 2014-03-06 09:12:00 +0000 | [diff] [blame] | 508 | |
henrik.lundin@webrtc.org | 6ea4f63 | 2014-03-13 09:21:26 +0000 | [diff] [blame] | 509 | TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) { RunRampUpDownUpTest(3, true); } |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 510 | |
pbos@webrtc.org | 744fbc7 | 2013-09-10 09:26:25 +0000 | [diff] [blame] | 511 | } // namespace webrtc |