Adapt encoder behavior to target bitrate

remoting/protocol/webrtc_frame_scheduler.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef REMOTING_PROTOCOL_WEBRTC_FRAME_SCHEDULER_H_
 #define REMOTING_PROTOCOL_WEBRTC_FRAME_SCHEDULER_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/thread_checker.h"
 #include "base/timer/timer.h"
+#include "media/capture/content/feedback_signal_accumulator.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/protocol/video_stream.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 namespace protocol {
 
+namespace {
+
+// Max Quantizer value.
+const int kMaxQuantizer = 63;
+
+// Default target bitrate in kbps
+const int kDefaultTargetBitrateKbps = 1000;
+
+}  // namespace
+
 // Class responsible for scheduling frames for encode and hand-over to
 // WebRtc transport for sending across the network.
 class WebRtcFrameScheduler : public webrtc::DesktopCapturer::Callback {
  public:
   WebRtcFrameScheduler(
       scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
       std::unique_ptr<webrtc::DesktopCapturer> capturer,
       WebrtcTransport* webrtc_transport,
       std::unique_ptr<VideoEncoder> encoder);
   ~WebRtcFrameScheduler() override;
@@ skipping 12 matching lines @@
   webrtc::SharedMemory* CreateSharedMemory(size_t size) override;
   void OnCaptureCompleted(webrtc::DesktopFrame* frame) override;
 
   // Callback for CaptureScheduler.
   void CaptureNextFrame();
 
   // Task running on the encoder thread to encode the |frame|.
   static std::unique_ptr<VideoPacket> EncodeFrame(
       VideoEncoder* encoder,
       std::unique_ptr<webrtc::DesktopFrame> frame,
-      bool key_frame_request);
+      uint32_t target_bitrate,
+      int64_t frame_duration_us,
+      bool key_frame_request,
+      int64_t capture_time_ms);
   void OnFrameEncoded(std::unique_ptr<VideoPacket> packet);
 
   void SetKeyFrameRequest();
   bool ClearAndGetKeyFrameRequest();
+  void SetTargetBitrate(uint32_t bitrate);
 
-  // Protects |key_frame_request_|.
+  // Protects |key_frame_request_| and |target_bitrate_kbps_|.
   base::Lock lock_;
   bool key_frame_request_ = false;
+  uint32_t target_bitrate_kbps_ = kDefaultTargetBitrateKbps;
+  int last_quantizer_ = kMaxQuantizer;
 
   bool capture_pending_ = false;
   bool encode_pending_ = false;
 
+  // Accumulated frame duration.
+  media::FeedbackSignalAccumulator<base::TimeTicks> acc_frame_duration_;
+  // Last time capture was completed.
+  base::TimeTicks last_capture_completed_ticks_;
+  // Last time capture was started.
+  base::TimeTicks last_capture_started_ticks_;
+
   webrtc::DesktopSize frame_size_;
   webrtc::DesktopVector frame_dpi_;
   VideoStream::SizeCallback size_callback_;
 
   // Task runner used to run |encoder_|.
   scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner_;
   base::CancelableTaskTracker task_tracker_;
 
   // Capturer used to capture the screen.
   std::unique_ptr<webrtc::DesktopCapturer> capturer_;
 
   std::unique_ptr<base::RepeatingTimer> capture_timer_;
 
   // Used to send across encoded frames.
   WebrtcTransport* webrtc_transport_;
 
   // Used to encode captured frames. Always accessed on the encode thread.
   std::unique_ptr<VideoEncoder> encoder_;
 
   base::ThreadChecker thread_checker_;
-  base::TimeTicks last_capture_ticks_;
 
   base::WeakPtrFactory<WebRtcFrameScheduler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebRtcFrameScheduler);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_WEBRTC_FRAME_SCHEDULER_H_