mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +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 | */ |
| 10 | |
| 11 | #include "webrtc/video_engine/overuse_frame_detector.h" |
| 12 | |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 13 | #include <assert.h> |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 14 | #include <math.h> |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 15 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 16 | #include <algorithm> |
| 17 | #include <list> |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 18 | #include <map> |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 19 | |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 20 | #include "webrtc/base/exp_filter.h" |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 21 | #include "webrtc/system_wrappers/interface/clock.h" |
| 22 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 23 | #include "webrtc/system_wrappers/interface/logging.h" |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 24 | |
| 25 | namespace webrtc { |
| 26 | |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 27 | // TODO(mflodman) Test different values for all of these to trigger correctly, |
| 28 | // avoid fluctuations etc. |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 29 | namespace { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 30 | const int64_t kProcessIntervalMs = 5000; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 31 | |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 32 | // Weight factor to apply to the standard deviation. |
| 33 | const float kWeightFactor = 0.997f; |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 34 | // Weight factor to apply to the average. |
| 35 | const float kWeightFactorMean = 0.98f; |
| 36 | |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 37 | // Delay between consecutive rampups. (Used for quick recovery.) |
| 38 | const int kQuickRampUpDelayMs = 10 * 1000; |
| 39 | // Delay between rampup attempts. Initially uses standard, scales up to max. |
asapersson@webrtc.org | c2ef523 | 2014-08-13 14:33:49 +0000 | [diff] [blame] | 40 | const int kStandardRampUpDelayMs = 40 * 1000; |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 41 | const int kMaxRampUpDelayMs = 240 * 1000; |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 42 | // Expontential back-off factor, to prevent annoying up-down behaviour. |
| 43 | const double kRampUpBackoffFactor = 2.0; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 44 | |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 45 | // Max number of overuses detected before always applying the rampup delay. |
asapersson@webrtc.org | c2ef523 | 2014-08-13 14:33:49 +0000 | [diff] [blame] | 46 | const int kMaxOverusesBeforeApplyRampupDelay = 4; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 47 | |
| 48 | // The maximum exponent to use in VCMExpFilter. |
| 49 | const float kSampleDiffMs = 33.0f; |
| 50 | const float kMaxExp = 7.0f; |
| 51 | |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 52 | } // namespace |
| 53 | |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 54 | Statistics::Statistics() : |
| 55 | sum_(0.0), |
| 56 | count_(0), |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 57 | filtered_samples_(new rtc::ExpFilter(kWeightFactorMean)), |
| 58 | filtered_variance_(new rtc::ExpFilter(kWeightFactor)) { |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 59 | Reset(); |
| 60 | } |
| 61 | |
| 62 | void Statistics::SetOptions(const CpuOveruseOptions& options) { |
| 63 | options_ = options; |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 64 | } |
| 65 | |
| 66 | void Statistics::Reset() { |
| 67 | sum_ = 0.0; |
| 68 | count_ = 0; |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 69 | filtered_variance_->Reset(kWeightFactor); |
| 70 | filtered_variance_->Apply(1.0f, InitialVariance()); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 71 | } |
| 72 | |
| 73 | void Statistics::AddSample(float sample_ms) { |
| 74 | sum_ += sample_ms; |
| 75 | ++count_; |
| 76 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 77 | if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) { |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 78 | // Initialize filtered samples. |
| 79 | filtered_samples_->Reset(kWeightFactorMean); |
| 80 | filtered_samples_->Apply(1.0f, InitialMean()); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 81 | return; |
| 82 | } |
| 83 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 84 | float exp = sample_ms / kSampleDiffMs; |
| 85 | exp = std::min(exp, kMaxExp); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 86 | filtered_samples_->Apply(exp, sample_ms); |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 87 | filtered_variance_->Apply(exp, (sample_ms - filtered_samples_->filtered()) * |
| 88 | (sample_ms - filtered_samples_->filtered())); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | float Statistics::InitialMean() const { |
| 92 | if (count_ == 0) |
| 93 | return 0.0; |
| 94 | return sum_ / count_; |
| 95 | } |
| 96 | |
| 97 | float Statistics::InitialVariance() const { |
| 98 | // Start in between the underuse and overuse threshold. |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 99 | float average_stddev = (options_.low_capture_jitter_threshold_ms + |
| 100 | options_.high_capture_jitter_threshold_ms) / 2.0f; |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 101 | return average_stddev * average_stddev; |
| 102 | } |
| 103 | |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 104 | float Statistics::Mean() const { return filtered_samples_->filtered(); } |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 105 | |
| 106 | float Statistics::StdDev() const { |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 107 | return sqrt(std::max(filtered_variance_->filtered(), 0.0f)); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 108 | } |
| 109 | |
| 110 | uint64_t Statistics::Count() const { return count_; } |
| 111 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 112 | |
| 113 | // Class for calculating the average encode time. |
| 114 | class OveruseFrameDetector::EncodeTimeAvg { |
| 115 | public: |
| 116 | EncodeTimeAvg() |
| 117 | : kWeightFactor(0.5f), |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 118 | kInitialAvgEncodeTimeMs(5.0f), |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 119 | filtered_encode_time_ms_(new rtc::ExpFilter(kWeightFactor)) { |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 120 | filtered_encode_time_ms_->Apply(1.0f, kInitialAvgEncodeTimeMs); |
| 121 | } |
| 122 | ~EncodeTimeAvg() {} |
| 123 | |
| 124 | void AddEncodeSample(float encode_time_ms, int64_t diff_last_sample_ms) { |
| 125 | float exp = diff_last_sample_ms / kSampleDiffMs; |
| 126 | exp = std::min(exp, kMaxExp); |
| 127 | filtered_encode_time_ms_->Apply(exp, encode_time_ms); |
| 128 | } |
| 129 | |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 130 | int Value() const { |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 131 | return static_cast<int>(filtered_encode_time_ms_->filtered() + 0.5); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 132 | } |
| 133 | |
| 134 | private: |
| 135 | const float kWeightFactor; |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 136 | const float kInitialAvgEncodeTimeMs; |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 137 | scoped_ptr<rtc::ExpFilter> filtered_encode_time_ms_; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 138 | }; |
| 139 | |
| 140 | // Class for calculating the encode usage. |
| 141 | class OveruseFrameDetector::EncodeUsage { |
| 142 | public: |
| 143 | EncodeUsage() |
| 144 | : kWeightFactorFrameDiff(0.998f), |
| 145 | kWeightFactorEncodeTime(0.995f), |
asapersson@webrtc.org | c773ded | 2014-05-13 13:45:13 +0000 | [diff] [blame] | 146 | kInitialSampleDiffMs(40.0f), |
| 147 | kMaxSampleDiffMs(45.0f), |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 148 | count_(0), |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 149 | filtered_encode_time_ms_(new rtc::ExpFilter(kWeightFactorEncodeTime)), |
| 150 | filtered_frame_diff_ms_(new rtc::ExpFilter(kWeightFactorFrameDiff)) { |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 151 | Reset(); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 152 | } |
| 153 | ~EncodeUsage() {} |
| 154 | |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 155 | void SetOptions(const CpuOveruseOptions& options) { |
| 156 | options_ = options; |
| 157 | } |
| 158 | |
| 159 | void Reset() { |
| 160 | count_ = 0; |
| 161 | filtered_frame_diff_ms_->Reset(kWeightFactorFrameDiff); |
| 162 | filtered_frame_diff_ms_->Apply(1.0f, kInitialSampleDiffMs); |
| 163 | filtered_encode_time_ms_->Reset(kWeightFactorEncodeTime); |
| 164 | filtered_encode_time_ms_->Apply(1.0f, InitialEncodeTimeMs()); |
| 165 | } |
| 166 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 167 | void AddSample(float sample_ms) { |
| 168 | float exp = sample_ms / kSampleDiffMs; |
| 169 | exp = std::min(exp, kMaxExp); |
| 170 | filtered_frame_diff_ms_->Apply(exp, sample_ms); |
| 171 | } |
| 172 | |
| 173 | void AddEncodeSample(float encode_time_ms, int64_t diff_last_sample_ms) { |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 174 | ++count_; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 175 | float exp = diff_last_sample_ms / kSampleDiffMs; |
| 176 | exp = std::min(exp, kMaxExp); |
| 177 | filtered_encode_time_ms_->Apply(exp, encode_time_ms); |
| 178 | } |
| 179 | |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 180 | int Value() const { |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 181 | if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) { |
| 182 | return static_cast<int>(InitialUsageInPercent() + 0.5f); |
| 183 | } |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 184 | float frame_diff_ms = std::max(filtered_frame_diff_ms_->filtered(), 1.0f); |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 185 | frame_diff_ms = std::min(frame_diff_ms, kMaxSampleDiffMs); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 186 | float encode_usage_percent = |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 187 | 100.0f * filtered_encode_time_ms_->filtered() / frame_diff_ms; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 188 | return static_cast<int>(encode_usage_percent + 0.5); |
| 189 | } |
| 190 | |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 191 | private: |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 192 | float InitialUsageInPercent() const { |
| 193 | // Start in between the underuse and overuse threshold. |
| 194 | return (options_.low_encode_usage_threshold_percent + |
| 195 | options_.high_encode_usage_threshold_percent) / 2.0f; |
| 196 | } |
| 197 | |
| 198 | float InitialEncodeTimeMs() const { |
| 199 | return InitialUsageInPercent() * kInitialSampleDiffMs / 100; |
| 200 | } |
| 201 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 202 | const float kWeightFactorFrameDiff; |
| 203 | const float kWeightFactorEncodeTime; |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 204 | const float kInitialSampleDiffMs; |
| 205 | const float kMaxSampleDiffMs; |
| 206 | uint64_t count_; |
| 207 | CpuOveruseOptions options_; |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 208 | scoped_ptr<rtc::ExpFilter> filtered_encode_time_ms_; |
| 209 | scoped_ptr<rtc::ExpFilter> filtered_frame_diff_ms_; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 210 | }; |
| 211 | |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 212 | // Class for calculating the relative standard deviation of encode times. |
| 213 | class OveruseFrameDetector::EncodeTimeRsd { |
| 214 | public: |
| 215 | EncodeTimeRsd(Clock* clock) |
| 216 | : kWeightFactor(0.6f), |
| 217 | count_(0), |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 218 | filtered_rsd_(new rtc::ExpFilter(kWeightFactor)), |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 219 | hist_samples_(0), |
| 220 | hist_sum_(0.0f), |
| 221 | last_process_time_ms_(clock->TimeInMilliseconds()) { |
| 222 | Reset(); |
| 223 | } |
| 224 | ~EncodeTimeRsd() {} |
| 225 | |
| 226 | void SetOptions(const CpuOveruseOptions& options) { |
| 227 | options_ = options; |
| 228 | } |
| 229 | |
| 230 | void Reset() { |
| 231 | count_ = 0; |
| 232 | filtered_rsd_->Reset(kWeightFactor); |
| 233 | filtered_rsd_->Apply(1.0f, InitialValue()); |
| 234 | hist_.clear(); |
| 235 | hist_samples_ = 0; |
| 236 | hist_sum_ = 0.0f; |
| 237 | } |
| 238 | |
| 239 | void AddEncodeSample(float encode_time_ms) { |
| 240 | int bin = static_cast<int>(encode_time_ms + 0.5f); |
| 241 | if (bin <= 0) { |
| 242 | // The frame was probably not encoded, skip possible dropped frame. |
| 243 | return; |
| 244 | } |
| 245 | ++count_; |
| 246 | ++hist_[bin]; |
| 247 | ++hist_samples_; |
| 248 | hist_sum_ += bin; |
| 249 | } |
| 250 | |
| 251 | void Process(int64_t now) { |
| 252 | if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) { |
| 253 | // Have not received min number of frames since last reset. |
| 254 | return; |
| 255 | } |
| 256 | const int kMinHistSamples = 20; |
| 257 | if (hist_samples_ < kMinHistSamples) { |
| 258 | return; |
| 259 | } |
| 260 | const int64_t kMinDiffSinceLastProcessMs = 1000; |
| 261 | int64_t diff_last_process_ms = now - last_process_time_ms_; |
| 262 | if (now - last_process_time_ms_ <= kMinDiffSinceLastProcessMs) { |
| 263 | return; |
| 264 | } |
| 265 | last_process_time_ms_ = now; |
| 266 | |
| 267 | // Calculate variance (using samples above the mean). |
| 268 | // Checks for a larger encode time of some frames while there is a small |
| 269 | // increase in the average time. |
| 270 | int mean = hist_sum_ / hist_samples_; |
| 271 | float variance = 0.0f; |
| 272 | int total_count = 0; |
| 273 | for (std::map<int,int>::iterator it = hist_.begin(); |
| 274 | it != hist_.end(); ++it) { |
| 275 | int time = it->first; |
| 276 | int count = it->second; |
| 277 | if (time > mean) { |
| 278 | total_count += count; |
| 279 | for (int i = 0; i < count; ++i) { |
| 280 | variance += ((time - mean) * (time - mean)); |
| 281 | } |
| 282 | } |
| 283 | } |
| 284 | variance /= std::max(total_count, 1); |
| 285 | float cov = sqrt(variance) / mean; |
| 286 | |
| 287 | hist_.clear(); |
| 288 | hist_samples_ = 0; |
| 289 | hist_sum_ = 0.0f; |
| 290 | |
| 291 | float exp = static_cast<float>(diff_last_process_ms) / kProcessIntervalMs; |
| 292 | exp = std::min(exp, kMaxExp); |
| 293 | filtered_rsd_->Apply(exp, 100.0f * cov); |
| 294 | } |
| 295 | |
| 296 | int Value() const { |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 297 | return static_cast<int>(filtered_rsd_->filtered() + 0.5); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 298 | } |
| 299 | |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 300 | private: |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 301 | float InitialValue() const { |
| 302 | // Start in between the underuse and overuse threshold. |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 303 | return std::max(((options_.low_encode_time_rsd_threshold + |
| 304 | options_.high_encode_time_rsd_threshold) / 2.0f), 0.0f); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 305 | } |
| 306 | |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 307 | const float kWeightFactor; |
| 308 | uint32_t count_; // Number of encode samples since last reset. |
| 309 | CpuOveruseOptions options_; |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 310 | scoped_ptr<rtc::ExpFilter> filtered_rsd_; |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 311 | int hist_samples_; |
| 312 | float hist_sum_; |
| 313 | std::map<int,int> hist_; // Histogram of encode time of frames. |
| 314 | int64_t last_process_time_ms_; |
| 315 | }; |
| 316 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 317 | // Class for calculating the capture queue delay change. |
| 318 | class OveruseFrameDetector::CaptureQueueDelay { |
| 319 | public: |
| 320 | CaptureQueueDelay() |
| 321 | : kWeightFactor(0.5f), |
| 322 | delay_ms_(0), |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 323 | filtered_delay_ms_per_s_(new rtc::ExpFilter(kWeightFactor)) { |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 324 | filtered_delay_ms_per_s_->Apply(1.0f, 0.0f); |
| 325 | } |
| 326 | ~CaptureQueueDelay() {} |
| 327 | |
| 328 | void FrameCaptured(int64_t now) { |
| 329 | const size_t kMaxSize = 200; |
| 330 | if (frames_.size() > kMaxSize) { |
| 331 | frames_.pop_front(); |
| 332 | } |
| 333 | frames_.push_back(now); |
| 334 | } |
| 335 | |
| 336 | void FrameProcessingStarted(int64_t now) { |
| 337 | if (frames_.empty()) { |
| 338 | return; |
| 339 | } |
| 340 | delay_ms_ = now - frames_.front(); |
| 341 | frames_.pop_front(); |
| 342 | } |
| 343 | |
| 344 | void CalculateDelayChange(int64_t diff_last_sample_ms) { |
| 345 | if (diff_last_sample_ms <= 0) { |
| 346 | return; |
| 347 | } |
| 348 | float exp = static_cast<float>(diff_last_sample_ms) / kProcessIntervalMs; |
| 349 | exp = std::min(exp, kMaxExp); |
| 350 | filtered_delay_ms_per_s_->Apply(exp, |
| 351 | delay_ms_ * 1000.0f / diff_last_sample_ms); |
| 352 | ClearFrames(); |
| 353 | } |
| 354 | |
| 355 | void ClearFrames() { |
| 356 | frames_.clear(); |
| 357 | } |
| 358 | |
| 359 | int delay_ms() const { |
| 360 | return delay_ms_; |
| 361 | } |
| 362 | |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 363 | int Value() const { |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 364 | return static_cast<int>(filtered_delay_ms_per_s_->filtered() + 0.5); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | private: |
| 368 | const float kWeightFactor; |
| 369 | std::list<int64_t> frames_; |
| 370 | int delay_ms_; |
minyue@webrtc.org | 31b38da | 2014-07-16 21:28:26 +0000 | [diff] [blame] | 371 | scoped_ptr<rtc::ExpFilter> filtered_delay_ms_per_s_; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 372 | }; |
| 373 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 374 | OveruseFrameDetector::OveruseFrameDetector(Clock* clock) |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 375 | : crit_(CriticalSectionWrapper::CreateCriticalSection()), |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 376 | observer_(NULL), |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 377 | clock_(clock), |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 378 | next_process_time_(clock_->TimeInMilliseconds()), |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 379 | num_process_times_(0), |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 380 | last_capture_time_(0), |
| 381 | last_overuse_time_(0), |
| 382 | checks_above_threshold_(0), |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 383 | num_overuse_detections_(0), |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 384 | last_rampup_time_(0), |
| 385 | in_quick_rampup_(false), |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 386 | current_rampup_delay_ms_(kStandardRampUpDelayMs), |
asapersson@webrtc.org | 4747585 | 2013-11-20 13:51:40 +0000 | [diff] [blame] | 387 | num_pixels_(0), |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 388 | last_encode_sample_ms_(0), |
| 389 | encode_time_(new EncodeTimeAvg()), |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 390 | encode_rsd_(new EncodeTimeRsd(clock)), |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 391 | encode_usage_(new EncodeUsage()), |
| 392 | capture_queue_delay_(new CaptureQueueDelay()) { |
| 393 | } |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 394 | |
| 395 | OveruseFrameDetector::~OveruseFrameDetector() { |
| 396 | } |
| 397 | |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 398 | void OveruseFrameDetector::SetObserver(CpuOveruseObserver* observer) { |
| 399 | CriticalSectionScoped cs(crit_.get()); |
| 400 | observer_ = observer; |
| 401 | } |
| 402 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 403 | void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) { |
| 404 | assert(options.min_frame_samples > 0); |
| 405 | CriticalSectionScoped cs(crit_.get()); |
| 406 | if (options_.Equals(options)) { |
| 407 | return; |
| 408 | } |
| 409 | options_ = options; |
| 410 | capture_deltas_.SetOptions(options); |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 411 | encode_usage_->SetOptions(options); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 412 | encode_rsd_->SetOptions(options); |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 413 | ResetAll(num_pixels_); |
| 414 | } |
| 415 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 416 | int OveruseFrameDetector::CaptureQueueDelayMsPerS() const { |
| 417 | CriticalSectionScoped cs(crit_.get()); |
| 418 | return capture_queue_delay_->delay_ms(); |
| 419 | } |
| 420 | |
asapersson@webrtc.org | 4e95436 | 2014-05-27 07:43:15 +0000 | [diff] [blame] | 421 | void OveruseFrameDetector::GetCpuOveruseMetrics( |
| 422 | CpuOveruseMetrics* metrics) const { |
| 423 | CriticalSectionScoped cs(crit_.get()); |
| 424 | metrics->capture_jitter_ms = static_cast<int>(capture_deltas_.StdDev() + 0.5); |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 425 | metrics->avg_encode_time_ms = encode_time_->Value(); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 426 | metrics->encode_rsd = encode_rsd_->Value(); |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 427 | metrics->encode_usage_percent = encode_usage_->Value(); |
| 428 | metrics->capture_queue_delay_ms_per_s = capture_queue_delay_->Value(); |
asapersson@webrtc.org | 4e95436 | 2014-05-27 07:43:15 +0000 | [diff] [blame] | 429 | } |
| 430 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 431 | int32_t OveruseFrameDetector::TimeUntilNextProcess() { |
| 432 | CriticalSectionScoped cs(crit_.get()); |
| 433 | return next_process_time_ - clock_->TimeInMilliseconds(); |
| 434 | } |
| 435 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 436 | bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const { |
| 437 | if (num_pixels != num_pixels_) { |
| 438 | return true; |
| 439 | } |
| 440 | return false; |
| 441 | } |
| 442 | |
| 443 | bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now) const { |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 444 | if (last_capture_time_ == 0) { |
| 445 | return false; |
| 446 | } |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 447 | return (now - last_capture_time_) > options_.frame_timeout_interval_ms; |
| 448 | } |
| 449 | |
| 450 | void OveruseFrameDetector::ResetAll(int num_pixels) { |
| 451 | num_pixels_ = num_pixels; |
| 452 | capture_deltas_.Reset(); |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 453 | encode_usage_->Reset(); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 454 | encode_rsd_->Reset(); |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 455 | capture_queue_delay_->ClearFrames(); |
| 456 | last_capture_time_ = 0; |
| 457 | num_process_times_ = 0; |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 458 | } |
| 459 | |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 460 | void OveruseFrameDetector::FrameCaptured(int width, int height) { |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 461 | CriticalSectionScoped cs(crit_.get()); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 462 | |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 463 | int64_t now = clock_->TimeInMilliseconds(); |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 464 | if (FrameSizeChanged(width * height) || FrameTimeoutDetected(now)) { |
| 465 | ResetAll(width * height); |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 466 | } |
| 467 | |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 468 | if (last_capture_time_ != 0) { |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 469 | capture_deltas_.AddSample(now - last_capture_time_); |
| 470 | encode_usage_->AddSample(now - last_capture_time_); |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 471 | } |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 472 | last_capture_time_ = now; |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 473 | |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 474 | capture_queue_delay_->FrameCaptured(now); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 475 | } |
| 476 | |
| 477 | void OveruseFrameDetector::FrameProcessingStarted() { |
| 478 | CriticalSectionScoped cs(crit_.get()); |
| 479 | capture_queue_delay_->FrameProcessingStarted(clock_->TimeInMilliseconds()); |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 480 | } |
| 481 | |
asapersson@webrtc.org | dd4f866 | 2013-11-26 11:12:33 +0000 | [diff] [blame] | 482 | void OveruseFrameDetector::FrameEncoded(int encode_time_ms) { |
asapersson@webrtc.org | 4747585 | 2013-11-20 13:51:40 +0000 | [diff] [blame] | 483 | CriticalSectionScoped cs(crit_.get()); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 484 | int64_t time = clock_->TimeInMilliseconds(); |
| 485 | if (last_encode_sample_ms_ != 0) { |
| 486 | int64_t diff_ms = time - last_encode_sample_ms_; |
| 487 | encode_time_->AddEncodeSample(encode_time_ms, diff_ms); |
| 488 | encode_usage_->AddEncodeSample(encode_time_ms, diff_ms); |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 489 | encode_rsd_->AddEncodeSample(encode_time_ms); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 490 | } |
| 491 | last_encode_sample_ms_ = time; |
asapersson@webrtc.org | dd4f866 | 2013-11-26 11:12:33 +0000 | [diff] [blame] | 492 | } |
| 493 | |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 494 | int32_t OveruseFrameDetector::Process() { |
| 495 | CriticalSectionScoped cs(crit_.get()); |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 496 | |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 497 | int64_t now = clock_->TimeInMilliseconds(); |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 498 | |
| 499 | // Used to protect against Process() being called too often. |
| 500 | if (now < next_process_time_) |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 501 | return 0; |
| 502 | |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 503 | int64_t diff_ms = now - next_process_time_ + kProcessIntervalMs; |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 504 | next_process_time_ = now + kProcessIntervalMs; |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 505 | ++num_process_times_; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 506 | |
asapersson@webrtc.org | 9cd8281 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 507 | encode_rsd_->Process(now); |
asapersson@webrtc.org | f1630b1 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 508 | capture_queue_delay_->CalculateDelayChange(diff_ms); |
| 509 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 510 | if (num_process_times_ <= options_.min_process_count) { |
asapersson@webrtc.org | 9950796 | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 511 | return 0; |
| 512 | } |
| 513 | |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 514 | if (IsOverusing()) { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 515 | // If the last thing we did was going up, and now have to back down, we need |
| 516 | // to check if this peak was short. If so we should back off to avoid going |
| 517 | // back and forth between this load, the system doesn't seem to handle it. |
| 518 | bool check_for_backoff = last_rampup_time_ > last_overuse_time_; |
| 519 | if (check_for_backoff) { |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 520 | if (now - last_rampup_time_ < kStandardRampUpDelayMs || |
| 521 | num_overuse_detections_ > kMaxOverusesBeforeApplyRampupDelay) { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 522 | // Going up was not ok for very long, back off. |
| 523 | current_rampup_delay_ms_ *= kRampUpBackoffFactor; |
| 524 | if (current_rampup_delay_ms_ > kMaxRampUpDelayMs) |
| 525 | current_rampup_delay_ms_ = kMaxRampUpDelayMs; |
| 526 | } else { |
| 527 | // Not currently backing off, reset rampup delay. |
| 528 | current_rampup_delay_ms_ = kStandardRampUpDelayMs; |
| 529 | } |
| 530 | } |
| 531 | |
| 532 | last_overuse_time_ = now; |
| 533 | in_quick_rampup_ = false; |
| 534 | checks_above_threshold_ = 0; |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 535 | ++num_overuse_detections_; |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 536 | |
| 537 | if (observer_ != NULL) |
| 538 | observer_->OveruseDetected(); |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 539 | } else if (IsUnderusing(now)) { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 540 | last_rampup_time_ = now; |
| 541 | in_quick_rampup_ = true; |
| 542 | |
| 543 | if (observer_ != NULL) |
| 544 | observer_->NormalUsage(); |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 545 | } |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 546 | |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 547 | int rampup_delay = |
| 548 | in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_; |
asapersson@webrtc.org | eddcc63 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 549 | LOG(LS_VERBOSE) << " Frame stats: capture avg: " << capture_deltas_.Mean() |
| 550 | << " capture stddev " << capture_deltas_.StdDev() |
| 551 | << " encode usage " << encode_usage_->Value() |
| 552 | << " encode rsd " << encode_rsd_->Value() |
| 553 | << " overuse detections " << num_overuse_detections_ |
| 554 | << " rampup delay " << rampup_delay; |
asapersson@webrtc.org | ae14504 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 555 | return 0; |
| 556 | } |
| 557 | |
| 558 | bool OveruseFrameDetector::IsOverusing() { |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 559 | bool overusing = false; |
| 560 | if (options_.enable_capture_jitter_method) { |
| 561 | overusing = capture_deltas_.StdDev() >= |
| 562 | options_.high_capture_jitter_threshold_ms; |
| 563 | } else if (options_.enable_encode_usage_method) { |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 564 | bool encode_usage_overuse = |
| 565 | encode_usage_->Value() >= options_.high_encode_usage_threshold_percent; |
| 566 | bool encode_rsd_overuse = false; |
| 567 | if (options_.high_encode_time_rsd_threshold > 0) { |
| 568 | encode_rsd_overuse = |
| 569 | (encode_rsd_->Value() >= options_.high_encode_time_rsd_threshold); |
| 570 | } |
| 571 | overusing = encode_usage_overuse || encode_rsd_overuse; |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 572 | } |
| 573 | |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 574 | if (overusing) { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 575 | ++checks_above_threshold_; |
| 576 | } else { |
| 577 | checks_above_threshold_ = 0; |
| 578 | } |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 579 | return checks_above_threshold_ >= options_.high_threshold_consecutive_count; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 580 | } |
| 581 | |
| 582 | bool OveruseFrameDetector::IsUnderusing(int64_t time_now) { |
pbos@webrtc.org | ce9de71 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 583 | int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_; |
| 584 | if (time_now < last_rampup_time_ + delay) |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 585 | return false; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 586 | |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 587 | bool underusing = false; |
| 588 | if (options_.enable_capture_jitter_method) { |
| 589 | underusing = capture_deltas_.StdDev() < |
| 590 | options_.low_capture_jitter_threshold_ms; |
| 591 | } else if (options_.enable_encode_usage_method) { |
asapersson@webrtc.org | f6eaabf | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 592 | bool encode_usage_underuse = |
| 593 | encode_usage_->Value() < options_.low_encode_usage_threshold_percent; |
| 594 | bool encode_rsd_underuse = true; |
| 595 | if (options_.low_encode_time_rsd_threshold > 0) { |
| 596 | encode_rsd_underuse = |
| 597 | (encode_rsd_->Value() < options_.low_encode_time_rsd_threshold); |
| 598 | } |
| 599 | underusing = encode_usage_underuse && encode_rsd_underuse; |
asapersson@webrtc.org | 154951d | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 600 | } |
asapersson@webrtc.org | 9da327c | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 601 | return underusing; |
mflodman@webrtc.org | cb9a72b | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 602 | } |
mflodman@webrtc.org | f8f91d6 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 603 | } // namespace webrtc |