Set overuse detector max frame interval based on target frame rate.

webrtc/video/vie_encoder.h

 /*
  *  Copyright (c) 2012 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.
  */
 
@@ skipping 111 matching lines @@
 
  protected:
   // Used for testing. For example the |ScalingObserverInterface| methods must
   // be called on |encoder_queue_|.
   rtc::TaskQueue* encoder_queue() { return &encoder_queue_; }
 
   // webrtc::ScalingObserverInterface implementation.
   // These methods are protected for easier testing.
   void AdaptUp(AdaptReason reason) override;
   void AdaptDown(AdaptReason reason) override;
+  static CpuOveruseOptions GetCpuOveruseOptions(bool full_overuse_time);
+
+  void UpdateOveruseDetector(
+      std::unique_ptr<OveruseFrameDetector> overuse_detector);
 
  private:
   class ConfigureEncoderTask;
   class EncodeTask;
   class VideoSourceProxy;
 
   class VideoFrameInfo {
    public:
     VideoFrameInfo(int width,
                    int height,
@@ skipping 80 matching lines @@
   const uint32_t number_of_cores_;
   // Counts how many frames we've dropped in the initial rampup phase.
   int initial_rampup_;
 
   const std::unique_ptr<VideoSourceProxy> source_proxy_;
   EncoderSink* sink_;
   const VideoSendStream::Config::EncoderSettings settings_;
   const VideoCodecType codec_type_;
 
   vcm::VideoSender video_sender_ ACCESS_ON(&encoder_queue_);
-  OveruseFrameDetector overuse_detector_ ACCESS_ON(&encoder_queue_);
+  std::unique_ptr<OveruseFrameDetector> overuse_detector_
+      ACCESS_ON(&encoder_queue_);
   std::unique_ptr<QualityScaler> quality_scaler_ ACCESS_ON(&encoder_queue_);
 
   SendStatisticsProxy* const stats_proxy_;
   rtc::VideoSinkInterface<VideoFrame>* const pre_encode_callback_;
   ProcessThread* module_process_thread_;
   rtc::ThreadChecker module_process_thread_checker_;
   // |thread_checker_| checks that public methods that are related to lifetime
   // of ViEEncoder are called on the same thread.
   rtc::ThreadChecker thread_checker_;
 
   VideoEncoderConfig encoder_config_ ACCESS_ON(&encoder_queue_);
   std::unique_ptr<VideoBitrateAllocator> rate_allocator_
       ACCESS_ON(&encoder_queue_);
+  // The maximum frame rate of the current codec configuration, as determined
+  // at the last ReconfigureEncoder() call.
+  int max_framerate_ ACCESS_ON(&encoder_queue_);

[kthelgason, 2017/06/12 11:56:48]

we already store the VideoEncoderConfig. Isn't this info taken from there?

[sprang_webrtc, 2017/06/14 08:39:17]

You'd think so, but it actually doesn't (explicitly) hold the max framerate.
It's instead assigned by the VideoStreamFactoryInterface instance pointed to by
the VideoEncoderConfig. In the chrome case, that lived is the
EncoderStreamFactory in webrtcvideoengine2, and its maximum is set at
construction time from a constraint.

The alternative is to store the entire std::vector<webrtc::VideoStream> returned
by the factory...

 
   // Set when ConfigureEncoder has been called in order to lazy reconfigure the
   // encoder on the next frame.
   bool pending_encoder_reconfiguration_ ACCESS_ON(&encoder_queue_);
   rtc::Optional<VideoFrameInfo> last_frame_info_ ACCESS_ON(&encoder_queue_);
   uint32_t encoder_start_bitrate_bps_ ACCESS_ON(&encoder_queue_);
   size_t max_data_payload_length_ ACCESS_ON(&encoder_queue_);
   bool nack_enabled_ ACCESS_ON(&encoder_queue_);
   uint32_t last_observed_bitrate_bps_ ACCESS_ON(&encoder_queue_);
   bool encoder_paused_and_dropped_frame_ ACCESS_ON(&encoder_queue_);
@@ skipping 40 matching lines @@
   // All public methods are proxied to |encoder_queue_|. It must must be
   // destroyed first to make sure no tasks are run that use other members.
   rtc::TaskQueue encoder_queue_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(ViEEncoder);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_VIDEO_VIE_ENCODER_H_