Implement video frame acknowledgements in the chromoting protocol.

remoting/host/video_scheduler.cc

 // Copyright (c) 2012 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.
 
 #include "remoting/host/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/protocol/message_decoder.h"
-#include "remoting/protocol/video_stub.h"
+#include "remoting/protocol/video_sender.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 
 namespace remoting {
 
-// Maximum number of frames that can be processed simultaneously.
+// Maximum number of frames that can be processed simultaneously. In case the
+// video channel has Ack messages enabled the VideoSender acknowledges frames
+// only after the corresponding Ack message is received. The values are chosen
+// experimentally to maximize frame rate, while keeping round-trip latency low.
 // TODO(hclam): Move this value to CaptureScheduler.
-static const int kMaxPendingFrames = 2;
+static const int kMaxPendingFrames = 4;

[Wez, 2015/01/21 01:35:38]

kMaxPendingFrames controls the number of screen-capture operations pending, IIRC
- our current capturers are only designed to cope with up to two capture frames
in-flight, i.e. they don't necessarily cope with more outstanding frames.

[Sergey Ulanov, 2015/01/29 01:33:27]

Fixed it now. CaptureScheduler now separately checks number of frames in the
encoder's queue and total number of frames.

+static const int kMaxPendingFramesWithoutAcks = 2;
 
 // Interval between empty keep-alive frames. These frames are sent only when the
 // stream is paused or inactive for some other reason (e.g. when blocked on
 // capturer). To prevent PseudoTCP from resetting congestion window this value
 // must be smaller than the minimum RTO used in PseudoTCP, which is 250ms.
 static const int kKeepAlivePacketIntervalMs = 200;
 
 static bool g_enable_timestamps = false;
 
 // static
 void VideoScheduler::EnableTimestampsForTests() {
   g_enable_timestamps = true;
 }
 
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<webrtc::DesktopCapturer> capturer,
     scoped_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
-    protocol::VideoStub* video_stub)
+    protocol::VideoSender* video_sender)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
       network_task_runner_(network_task_runner),
       capturer_(capturer.Pass()),
       mouse_cursor_monitor_(mouse_cursor_monitor.Pass()),
       encoder_(encoder.Pass()),
       cursor_stub_(cursor_stub),
-      video_stub_(video_stub),
+      video_sender_(video_sender),
       pending_frames_(0),
       capture_pending_(false),
       did_skip_frame_(false),
       is_paused_(false),
       latest_event_timestamp_(0) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(capturer_);
   DCHECK(mouse_cursor_monitor_);
   DCHECK(encoder_);
   DCHECK(cursor_stub_);
-  DCHECK(video_stub_);
+  DCHECK(video_sender_);
 }
 
 // Public methods --------------------------------------------------------------
 
 webrtc::SharedMemory* VideoScheduler::CreateSharedMemory(size_t size) {
   return nullptr;
 }
 
 void VideoScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
@@ skipping 65 matching lines @@
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
 }
 
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // Clear stubs to prevent further updates reaching the client.
   cursor_stub_ = nullptr;
-  video_stub_ = nullptr;
+  video_sender_ = nullptr;
 
   keep_alive_timer_.reset();
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StopOnCaptureThread, this));
 }
 
 void VideoScheduler::Pause(bool pause) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
@@ skipping 97 matching lines @@
                         &VideoScheduler::CaptureNextFrame);
 }
 
 void VideoScheduler::CaptureNextFrame() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // If we are stopping (|capturer_| is nullptr), or paused, then don't capture.
   if (!capturer_ || is_paused_)
     return;
 
+  int max_pending_frames = video_sender_->SupportsAcks()
+                               ? kMaxPendingFrames
+                               : kMaxPendingFramesWithoutAcks;
+
   // Make sure we have at most two outstanding recordings. We can simply return
   // if we can't make a capture now, the next capture will be started by the
   // end of an encode operation.
-  if (pending_frames_ >= kMaxPendingFrames || capture_pending_) {
+  if (pending_frames_ >= max_pending_frames || capture_pending_) {
     did_skip_frame_ = true;
     return;
   }
 
   did_skip_frame_ = false;
 
   // At this point we are going to perform one capture so save the current time.
   pending_frames_++;
-  DCHECK_LE(pending_frames_, kMaxPendingFrames);
+  DCHECK_LE(pending_frames_, max_pending_frames);
 
   // Before doing a capture schedule for the next one.
   ScheduleNextCapture();
 
   capture_pending_ = true;
 
   // Capture the mouse shape.
   mouse_cursor_monitor_->Capture();
 
   // And finally perform one capture.
@@ skipping 11 matching lines @@
   // pending then schedule one now.
   if (did_skip_frame_)
     CaptureNextFrame();
 }
 
 // Network thread --------------------------------------------------------------
 
 void VideoScheduler::SendVideoPacket(scoped_ptr<VideoPacket> packet) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (!video_stub_)
+  if (!video_sender_)
     return;
 
-  video_stub_->ProcessVideoPacket(
+  video_sender_->ProcessVideoPacket(
       packet.Pass(), base::Bind(&VideoScheduler::OnVideoPacketSent, this));
 }
 
 void VideoScheduler::OnVideoPacketSent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (!video_stub_)
+  if (!video_sender_)
     return;
 
   keep_alive_timer_->Reset();
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this));
 }
 
 void VideoScheduler::SendKeepAlivePacket() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
-  if (!video_stub_)
+  if (!video_sender_)
     return;
 
-  video_stub_->ProcessVideoPacket(
+  video_sender_->ProcessVideoPacket(
       make_scoped_ptr(new VideoPacket()),
       base::Bind(&VideoScheduler::OnKeepAlivePacketSent, this));
 }
 
 void VideoScheduler::OnKeepAlivePacketSent() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (keep_alive_timer_)
     keep_alive_timer_->Reset();
 }
@@ skipping 41 matching lines @@
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting