Let ViEEncoder express resolution requests as Sinkwants

webrtc/media/engine/webrtcvideoengine2.h

 /*
  *  Copyright (c) 2014 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 224 matching lines @@
   void DeleteReceiveStream(WebRtcVideoReceiveStream* stream)
       EXCLUSIVE_LOCKS_REQUIRED(stream_crit_);
 
   static std::string CodecSettingsVectorToString(
       const std::vector<VideoCodecSettings>& codecs);
 
   // Wrapper for the sender part, this is where the source is connected and
   // frames are then converted from cricket frames to webrtc frames.
   class WebRtcVideoSendStream
       : public rtc::VideoSinkInterface<cricket::VideoFrame>,
-        public rtc::VideoSourceInterface<webrtc::VideoFrame>,
-        public webrtc::LoadObserver {
+        public rtc::VideoSourceInterface<webrtc::VideoFrame> {
    public:
     WebRtcVideoSendStream(
         webrtc::Call* call,
         const StreamParams& sp,
         webrtc::VideoSendStream::Config config,
         const VideoOptions& options,
         WebRtcVideoEncoderFactory* external_encoder_factory,
         bool enable_cpu_overuse_detection,
         int max_bitrate_bps,
         const rtc::Optional<VideoCodecSettings>& codec_settings,
@@ skipping 12 matching lines @@
     // TODO(perkj, nisse): Refactor WebRtcVideoSendStream to directly connect
     // the camera input |source_|
     void AddOrUpdateSink(VideoSinkInterface<webrtc::VideoFrame>* sink,
                          const rtc::VideoSinkWants& wants) override;
     void RemoveSink(VideoSinkInterface<webrtc::VideoFrame>* sink) override;
 
     void OnFrame(const cricket::VideoFrame& frame) override;
     bool SetVideoSend(bool mute,
                       const VideoOptions* options,
                       rtc::VideoSourceInterface<cricket::VideoFrame>* source);
-    void DisconnectSource();
 
     void SetSend(bool send);
 
-    // Implements webrtc::LoadObserver.
-    void OnLoadUpdate(Load load) override;
-
     const std::vector<uint32_t>& GetSsrcs() const;
     VideoSenderInfo GetVideoSenderInfo(bool log_stats);
     void FillBandwidthEstimationInfo(BandwidthEstimationInfo* bwe_info);
 
    private:
     // Parameters needed to reconstruct the underlying stream.
     // webrtc::VideoSendStream doesn't support setting a lot of options on the
     // fly, so when those need to be changed we tear down and reconstruct with
     // similar parameters depending on which options changed etc.
     struct VideoSendStreamParameters {
@@ skipping 16 matching lines @@
     struct AllocatedEncoder {
       AllocatedEncoder(webrtc::VideoEncoder* encoder,
                        webrtc::VideoCodecType type,
                        bool external);
       webrtc::VideoEncoder* encoder;
       webrtc::VideoEncoder* external_encoder;
       webrtc::VideoCodecType type;
       bool external;
     };
 
-    // TODO(perkj): VideoFrameInfo is currently used for CPU adaptation since
-    // we currently do not express CPU overuse using SinkWants in lower
-    // layers. This will be fixed in an upcoming cl.
+    // TODO(perkj): VideoFrameInfo is currently used for sending a black frame
+    // when the video source is removed. Consider moving that logic to
+    // VieEncoder or remove it.
     struct VideoFrameInfo {
       VideoFrameInfo()
           : width(0),
             height(0),
             rotation(webrtc::kVideoRotation_0),
             is_texture(false) {}
       int width;
       int height;
       webrtc::VideoRotation rotation;
       bool is_texture;
@@ skipping 15 matching lines @@
     void UpdateSendState();
 
     void UpdateHistograms() const EXCLUSIVE_LOCKS_REQUIRED(lock_);
 
     rtc::ThreadChecker thread_checker_;
     rtc::AsyncInvoker invoker_;
     rtc::Thread* worker_thread_;
     const std::vector<uint32_t> ssrcs_ ACCESS_ON(&thread_checker_);
     const std::vector<SsrcGroup> ssrc_groups_ ACCESS_ON(&thread_checker_);
     webrtc::Call* const call_;
-    rtc::VideoSinkWants sink_wants_ ACCESS_ON(&thread_checker_);
-    // Counter used for deciding if the video resolution is currently
-    // restricted by CPU usage. It is reset if |source_| is changed.
-    int cpu_restricted_counter_;
-    // Total number of times resolution as been requested to be changed due to
-    // CPU adaptation.
-    int number_of_cpu_adapt_changes_ ACCESS_ON(&thread_checker_);
-    // Total number of frames sent to |stream_|.
-    int frame_count_ GUARDED_BY(lock_);
-    // Total number of cpu restricted frames sent to |stream_|.
-    int cpu_restricted_frame_count_ GUARDED_BY(lock_);
+    const bool enable_cpu_overuse_detection_;
     rtc::VideoSourceInterface<cricket::VideoFrame>* source_
         ACCESS_ON(&thread_checker_);
     WebRtcVideoEncoderFactory* const external_encoder_factory_
         ACCESS_ON(&thread_checker_);
 
     rtc::CriticalSection lock_;
     webrtc::VideoSendStream* stream_ ACCESS_ON(&thread_checker_);
     rtc::VideoSinkInterface<webrtc::VideoFrame>* encoder_sink_
         GUARDED_BY(lock_);
     // Contains settings that are the same for all streams in the MediaChannel,
@@ skipping 157 matching lines @@
   VideoSendParameters send_params_;
   VideoOptions default_send_options_;
   VideoRecvParameters recv_params_;
   bool red_disabled_by_remote_side_;
   int64_t last_stats_log_ms_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_WEBRTCVIDEOENGINE2_H_