1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
* 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.
*/
#ifndef WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_
#define WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/exp_filter.h"
#include "webrtc/base/thread_annotations.h"
#include "webrtc/modules/interface/module.h"
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
#include "webrtc/video_engine/include/vie_base.h"
namespace webrtc {
class Clock;
class CpuOveruseObserver;
class CriticalSectionWrapper;
// TODO(pbos): Move this somewhere appropriate.
class Statistics {
public:
Statistics();
void AddSample(float sample_ms);
void Reset();
void SetOptions(const CpuOveruseOptions& options);
float Mean() const;
float StdDev() const;
uint64_t Count() const;
private:
float InitialMean() const;
float InitialVariance() const;
float sum_;
uint64_t count_;
CpuOveruseOptions options_;
scoped_ptr<rtc::ExpFilter> filtered_samples_;
scoped_ptr<rtc::ExpFilter> filtered_variance_;
};
// Use to detect system overuse based on jitter in incoming frames.
class OveruseFrameDetector : public Module {
public:
explicit OveruseFrameDetector(Clock* clock);
~OveruseFrameDetector();
// 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);
// Accessors.
// Returns CpuOveruseMetrics where
// capture_jitter_ms: The estimated jitter based on incoming captured frames.
// avg_encode_time_ms: Running average of reported encode time
// (FrameEncoded()). Only used for stats.
// TODO(asapersson): Rename metric.
// encode_usage_percent: The average processing time of a frame on the
// send-side divided by the average time difference
// between incoming captured frames.
// capture_queue_delay_ms_per_s: The current time delay between an incoming
// captured frame (FrameCaptured()) until the
// frame is being processed
// (FrameProcessingStarted()). (Note: if a new
// frame is received before an old frame has
// been processed, the old frame is skipped).
// The delay is expressed in ms delay per sec.
// Only used for stats.
void GetCpuOveruseMetrics(CpuOveruseMetrics* metrics) const;
// Only public for testing.
int CaptureQueueDelayMsPerS() const;
int LastProcessingTimeMs() const;
int FramesInQueue() const;
// Implements Module.
virtual int64_t TimeUntilNextProcess() OVERRIDE;
virtual int32_t Process() OVERRIDE;
private:
class EncodeTimeAvg;
class SendProcessingUsage;
class CaptureQueueDelay;
class FrameQueue;
void AddProcessingTime(int elapsed_ms) EXCLUSIVE_LOCKS_REQUIRED(crit_);
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.
scoped_ptr<CriticalSectionWrapper> crit_;
// Observer getting overuse reports.
CpuOveruseObserver* observer_ GUARDED_BY(crit_);
CpuOveruseOptions options_ GUARDED_BY(crit_);
Clock* clock_;
int64_t next_process_time_;
int64_t num_process_times_ GUARDED_BY(crit_);
Statistics capture_deltas_ GUARDED_BY(crit_);
int64_t last_capture_time_ GUARDED_BY(crit_);
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_ GUARDED_BY(crit_);
scoped_ptr<EncodeTimeAvg> encode_time_ GUARDED_BY(crit_);
scoped_ptr<SendProcessingUsage> usage_ GUARDED_BY(crit_);
scoped_ptr<FrameQueue> frame_queue_ GUARDED_BY(crit_);
int64_t last_sample_time_ms_ GUARDED_BY(crit_);
scoped_ptr<CaptureQueueDelay> capture_queue_delay_ GUARDED_BY(crit_);
DISALLOW_COPY_AND_ASSIGN(OveruseFrameDetector);
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_
|
