src/third_party/webrtc/video_engine/overuse_frame_detector.h

   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 #ifndef WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_
  12 #define WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_
  13
  14 #include "webrtc/base/constructormagic.h"
  15 #include "webrtc/modules/interface/module.h"
  16 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
  17 #include "webrtc/video_engine/include/vie_base.h"
  18
  19 namespace webrtc {
  20
  21 class Clock;
  22 class CpuOveruseObserver;
  23 class CriticalSectionWrapper;
  24 class VCMExpFilter;
  25
  26 // TODO(pbos): Move this somewhere appropriate.
  27 class Statistics {
  28  public:
  29   Statistics();
  30
  31   void AddSample(float sample_ms);
  32   void Reset();
  33   void SetOptions(const CpuOveruseOptions& options);
  34
  35   float Mean() const;
  36   float StdDev() const;
  37   uint64_t Count() const;
  38
  39  private:
  40   float InitialMean() const;
  41   float InitialVariance() const;
  42
  43   float sum_;
  44   uint64_t count_;
  45   CpuOveruseOptions options_;
  46   scoped_ptr<VCMExpFilter> filtered_samples_;
  47   scoped_ptr<VCMExpFilter> filtered_variance_;
  48 };
  49
  50 // Use to detect system overuse based on jitter in incoming frames.
  51 class OveruseFrameDetector : public Module {
  52  public:
  53   explicit OveruseFrameDetector(Clock* clock);
  54   ~OveruseFrameDetector();
  55
  56   // Registers an observer receiving overuse and underuse callbacks. Set
  57   // 'observer' to NULL to disable callbacks.
  58   void SetObserver(CpuOveruseObserver* observer);
  59
  60   // Sets options for overuse detection.
  61   void SetOptions(const CpuOveruseOptions& options);
  62
  63   // Called for each captured frame.
  64   void FrameCaptured(int width, int height);
  65
  66   // Called when the processing of a captured frame is started.
  67   void FrameProcessingStarted();
  68
  69   // Called for each encoded frame.
  70   void FrameEncoded(int encode_time_ms);
  71
  72   // Accessors.
  73
  74   // Returns CpuOveruseMetrics where
  75   // capture_jitter_ms: The estimated jitter based on incoming captured frames.
  76   // avg_encode_time_ms: Running average of reported encode time
  77   //                     (FrameEncoded()). Only used for stats.
  78   // encode_usage_percent: The average encode time divided by the average time
  79   //                       difference between incoming captured frames.
  80   // capture_queue_delay_ms_per_s: The current time delay between an incoming
  81   //                               captured frame (FrameCaptured()) until the
  82   //                               frame is being processed
  83   //                               (FrameProcessingStarted()). (Note: if a new
  84   //                               frame is received before an old frame has
  85   //                               been processed, the old frame is skipped).
  86   //                               The delay is expressed in ms delay per sec.
  87   //                               Only used for stats.
  88   void GetCpuOveruseMetrics(CpuOveruseMetrics* metrics) const;
  89
  90   int CaptureQueueDelayMsPerS() const;
  91
  92   // Implements Module.
  93   virtual int32_t TimeUntilNextProcess() OVERRIDE;
  94   virtual int32_t Process() OVERRIDE;
  95
  96  private:
  97   class EncodeTimeAvg;
  98   class EncodeTimeRsd;
  99   class EncodeUsage;
 100   class CaptureQueueDelay;
 101
 102   bool IsOverusing();
 103   bool IsUnderusing(int64_t time_now);
 104
 105   bool FrameTimeoutDetected(int64_t now) const;
 106   bool FrameSizeChanged(int num_pixels) const;
 107
 108   void ResetAll(int num_pixels);
 109
 110   // Protecting all members.
 111   scoped_ptr<CriticalSectionWrapper> crit_;
 112
 113   // Observer getting overuse reports.
 114   CpuOveruseObserver* observer_;
 115
 116   CpuOveruseOptions options_;
 117
 118   Clock* clock_;
 119   int64_t next_process_time_;
 120   int64_t num_process_times_;
 121
 122   Statistics capture_deltas_;
 123   int64_t last_capture_time_;
 124
 125   int64_t last_overuse_time_;
 126   int checks_above_threshold_;
 127   int num_overuse_detections_;
 128
 129   int64_t last_rampup_time_;
 130   bool in_quick_rampup_;
 131   int current_rampup_delay_ms_;
 132
 133   // Number of pixels of last captured frame.
 134   int num_pixels_;
 135
 136   int64_t last_encode_sample_ms_;
 137   scoped_ptr<EncodeTimeAvg> encode_time_;
 138   scoped_ptr<EncodeTimeRsd> encode_rsd_;
 139   scoped_ptr<EncodeUsage> encode_usage_;
 140
 141   scoped_ptr<CaptureQueueDelay> capture_queue_delay_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(OveruseFrameDetector);
 144 };
 145
 146 }  // namespace webrtc
 147
 148 #endif  // WEBRTC_VIDEO_ENGINE_OVERUSE_FRAME_DETECTOR_H_