blob: 122cce505cab1fb8786cd6598d72f8d3166995f3 [file] [log] [blame]
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/criticalsection.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/base/exp_filter.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/base/thread_checker.h"
#include "webrtc/modules/interface/module.h"
namespace webrtc {
class Clock;
// CpuOveruseObserver is called when a system overuse is detected and
// VideoEngine cannot keep up the encoding frequency.
class CpuOveruseObserver {
// Called as soon as an overuse is detected.
virtual void OveruseDetected() = 0;
// Called periodically when the system is not overused any longer.
virtual void NormalUsage() = 0;
virtual ~CpuOveruseObserver() {}
struct CpuOveruseOptions {
: enable_capture_jitter_method(false),
high_threshold_consecutive_count(2) {}
// Method based on inter-arrival jitter of captured frames.
bool enable_capture_jitter_method;
float low_capture_jitter_threshold_ms; // Threshold for triggering underuse.
float high_capture_jitter_threshold_ms; // Threshold for triggering overuse.
// Method based on encode time of frames.
bool enable_encode_usage_method;
int low_encode_usage_threshold_percent; // Threshold for triggering underuse.
int high_encode_usage_threshold_percent; // Threshold for triggering overuse.
// TODO(asapersson): Remove options, not used.
int low_encode_time_rsd_threshold; // Additional threshold for triggering
// underuse (used in addition to
// threshold above if configured).
int high_encode_time_rsd_threshold; // Additional threshold for triggering
// overuse (used in addition to
// threshold above if configured).
bool enable_extended_processing_usage; // Include a larger time span (in
// addition to encode time) for
// measuring the processing time of a
// frame.
// General settings.
int frame_timeout_interval_ms; // The maximum allowed interval between two
// frames before resetting estimations.
int min_frame_samples; // The minimum number of frames required.
int min_process_count; // The number of initial process times required before
// triggering an overuse/underuse.
int high_threshold_consecutive_count; // The number of consecutive checks
// above the high threshold before
// triggering an overuse.
bool Equals(const CpuOveruseOptions& o) const {
return enable_capture_jitter_method == o.enable_capture_jitter_method &&
low_capture_jitter_threshold_ms == o.low_capture_jitter_threshold_ms &&
high_capture_jitter_threshold_ms ==
o.high_capture_jitter_threshold_ms &&
enable_encode_usage_method == o.enable_encode_usage_method &&
low_encode_usage_threshold_percent ==
o.low_encode_usage_threshold_percent &&
high_encode_usage_threshold_percent ==
o.high_encode_usage_threshold_percent &&
low_encode_time_rsd_threshold == o.low_encode_time_rsd_threshold &&
high_encode_time_rsd_threshold == o.high_encode_time_rsd_threshold &&
enable_extended_processing_usage ==
o.enable_extended_processing_usage &&
frame_timeout_interval_ms == o.frame_timeout_interval_ms &&
min_frame_samples == o.min_frame_samples &&
min_process_count == o.min_process_count &&
high_threshold_consecutive_count == o.high_threshold_consecutive_count;
struct CpuOveruseMetrics {
: capture_jitter_ms(-1),
capture_queue_delay_ms_per_s(-1) {}
int capture_jitter_ms; // The current estimated jitter in ms based on
// incoming captured frames.
int avg_encode_time_ms; // The average encode time in ms.
int encode_usage_percent; // The average encode time divided by the average
// time difference between incoming captured frames.
int capture_queue_delay_ms_per_s; // The current time delay between an
// incoming captured frame until the frame
// is being processed. The delay is
// expressed in ms delay per second.
class CpuOveruseMetricsObserver {
virtual ~CpuOveruseMetricsObserver() {}
virtual void CpuOveruseMetricsUpdated(const CpuOveruseMetrics& metrics) = 0;
// TODO(pbos): Move this somewhere appropriate.
class Statistics {
void AddSample(float sample_ms);
void Reset();
void SetOptions(const CpuOveruseOptions& options);
float Mean() const;
float StdDev() const;
uint64_t Count() const;
float InitialMean() const;
float InitialVariance() const;
float sum_;
uint64_t count_;
CpuOveruseOptions options_;
rtc::scoped_ptr<rtc::ExpFilter> filtered_samples_;
rtc::scoped_ptr<rtc::ExpFilter> filtered_variance_;
// Use to detect system overuse based on jitter in incoming frames.
class OveruseFrameDetector : public Module {
OveruseFrameDetector(Clock* clock,
CpuOveruseMetricsObserver* metrics_observer);
// Registers an observer receiving overuse and underuse callbacks. Set
// 'observer' to NULL to disable callbacks.
void SetObserver(CpuOveruseObserver* observer);
// Sets options for overuse detection.
void SetOptions(const CpuOveruseOptions& options);
// Called for each captured frame.
void FrameCaptured(int width, int height, int64_t capture_time_ms);
// Called when the processing of a captured frame is started.
void FrameProcessingStarted();
// Called for each encoded frame.
void FrameEncoded(int encode_time_ms);
// Called for each sent frame.
void FrameSent(int64_t capture_time_ms);
// Only public for testing.
int CaptureQueueDelayMsPerS() const;
int LastProcessingTimeMs() const;
int FramesInQueue() const;
// Implements Module.
int64_t TimeUntilNextProcess() override;
int32_t Process() override;
class EncodeTimeAvg;
class SendProcessingUsage;
class CaptureQueueDelay;
class FrameQueue;
void UpdateCpuOveruseMetrics() EXCLUSIVE_LOCKS_REQUIRED(crit_);
// TODO(asapersson): This method is only used on one thread, so it shouldn't
// need a guard.
void AddProcessingTime(int elapsed_ms) EXCLUSIVE_LOCKS_REQUIRED(crit_);
// TODO(asapersson): This method is always called on the processing thread.
// If locking is required, consider doing that locking inside the
// implementation and reduce scope as much as possible. We should also
// see if we can avoid calling out to other methods while holding the lock.
bool IsOverusing() EXCLUSIVE_LOCKS_REQUIRED(crit_);
bool IsUnderusing(int64_t time_now) EXCLUSIVE_LOCKS_REQUIRED(crit_);
bool FrameTimeoutDetected(int64_t now) const EXCLUSIVE_LOCKS_REQUIRED(crit_);
bool FrameSizeChanged(int num_pixels) const EXCLUSIVE_LOCKS_REQUIRED(crit_);
void ResetAll(int num_pixels) EXCLUSIVE_LOCKS_REQUIRED(crit_);
// Protecting all members except const and those that are only accessed on the
// processing thread.
// TODO(asapersson): See if we can reduce locking. As is, video frame
// processing contends with reading stats and the processing thread.
mutable rtc::CriticalSection crit_;
// Observer getting overuse reports.
CpuOveruseObserver* observer_ GUARDED_BY(crit_);
CpuOveruseOptions options_ GUARDED_BY(crit_);
// Stats metrics.
CpuOveruseMetricsObserver* const metrics_observer_;
CpuOveruseMetrics metrics_ GUARDED_BY(crit_);
Clock* const clock_;
int64_t next_process_time_; // Only accessed on the processing thread.
int64_t num_process_times_ GUARDED_BY(crit_);
Statistics capture_deltas_ GUARDED_BY(crit_);
int64_t last_capture_time_ GUARDED_BY(crit_);
// These six members are only accessed on the processing thread.
int64_t last_overuse_time_;
int checks_above_threshold_;
int num_overuse_detections_;
int64_t last_rampup_time_;
bool in_quick_rampup_;
int current_rampup_delay_ms_;
// Number of pixels of last captured frame.
int num_pixels_ GUARDED_BY(crit_);
int64_t last_encode_sample_ms_; // Only accessed by one thread.
// TODO(asapersson): Can these be regular members (avoid separate heap
// allocs)?
const rtc::scoped_ptr<EncodeTimeAvg> encode_time_ GUARDED_BY(crit_);
const rtc::scoped_ptr<SendProcessingUsage> usage_ GUARDED_BY(crit_);
const rtc::scoped_ptr<FrameQueue> frame_queue_ GUARDED_BY(crit_);
int64_t last_sample_time_ms_; // Only accessed by one thread.
const rtc::scoped_ptr<CaptureQueueDelay> capture_queue_delay_
rtc::ThreadChecker processing_thread_;
} // namespace webrtc