1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "remoting/host/video_scheduler.h" 6 7 #include <algorithm> 8 9 #include "base/bind.h" 10 #include "base/callback.h" 11 #include "base/logging.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/message_loop/message_loop_proxy.h" 14 #include "base/stl_util.h" 15 #include "base/sys_info.h" 16 #include "base/time/time.h" 17 #include "remoting/proto/control.pb.h" 18 #include "remoting/proto/internal.pb.h" 19 #include "remoting/proto/video.pb.h" 20 #include "remoting/protocol/cursor_shape_stub.h" 21 #include "remoting/protocol/message_decoder.h" 22 #include "remoting/protocol/util.h" 23 #include "remoting/protocol/video_stub.h" 24 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h" 25 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_shape.h" 26 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h" 27 28 namespace remoting { 29 30 // Maximum number of frames that can be processed simultaneously. 31 // TODO(hclam): Move this value to CaptureScheduler. 32 static const int kMaxPendingFrames = 2; 33 34 VideoScheduler::VideoScheduler( 35 scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner, 36 scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner, 37 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner, 38 scoped_ptr<webrtc::ScreenCapturer> capturer, 39 scoped_ptr<VideoEncoder> encoder, 40 protocol::CursorShapeStub* cursor_stub, 41 protocol::VideoStub* video_stub) 42 : capture_task_runner_(capture_task_runner), 43 encode_task_runner_(encode_task_runner), 44 network_task_runner_(network_task_runner), 45 capturer_(capturer.Pass()), 46 encoder_(encoder.Pass()), 47 cursor_stub_(cursor_stub), 48 video_stub_(video_stub), 49 pending_frames_(0), 50 capture_pending_(false), 51 did_skip_frame_(false), 52 is_paused_(false), 53 sequence_number_(0) { 54 DCHECK(network_task_runner_->BelongsToCurrentThread()); 55 DCHECK(capturer_); 56 DCHECK(encoder_); 57 DCHECK(cursor_stub_); 58 DCHECK(video_stub_); 59 } 60 61 // Public methods -------------------------------------------------------------- 62 63 webrtc::SharedMemory* VideoScheduler::CreateSharedMemory(size_t size) { 64 return NULL; 65 } 66 67 void VideoScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) { 68 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 69 70 capture_pending_ = false; 71 72 scoped_ptr<webrtc::DesktopFrame> owned_frame(frame); 73 74 if (frame) { 75 scheduler_.RecordCaptureTime( 76 base::TimeDelta::FromMilliseconds(frame->capture_time_ms())); 77 } 78 79 encode_task_runner_->PostTask( 80 FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, 81 base::Passed(&owned_frame), sequence_number_)); 82 83 // If a frame was skipped, try to capture it again. 84 if (did_skip_frame_) { 85 capture_task_runner_->PostTask( 86 FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this)); 87 } 88 } 89 90 void VideoScheduler::OnCursorShapeChanged( 91 webrtc::MouseCursorShape* cursor_shape) { 92 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 93 94 scoped_ptr<webrtc::MouseCursorShape> owned_cursor(cursor_shape); 95 96 // Do nothing if the scheduler is being stopped. 97 if (!capturer_) 98 return; 99 100 scoped_ptr<protocol::CursorShapeInfo> cursor_proto( 101 new protocol::CursorShapeInfo()); 102 cursor_proto->set_width(cursor_shape->size.width()); 103 cursor_proto->set_height(cursor_shape->size.height()); 104 cursor_proto->set_hotspot_x(cursor_shape->hotspot.x()); 105 cursor_proto->set_hotspot_y(cursor_shape->hotspot.y()); 106 cursor_proto->set_data(cursor_shape->data); 107 108 network_task_runner_->PostTask( 109 FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this, 110 base::Passed(&cursor_proto))); 111 } 112 113 void VideoScheduler::Start() { 114 DCHECK(network_task_runner_->BelongsToCurrentThread()); 115 116 capture_task_runner_->PostTask( 117 FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this)); 118 } 119 120 void VideoScheduler::Stop() { 121 DCHECK(network_task_runner_->BelongsToCurrentThread()); 122 123 // Clear stubs to prevent further updates reaching the client. 124 cursor_stub_ = NULL; 125 video_stub_ = NULL; 126 127 capture_task_runner_->PostTask(FROM_HERE, 128 base::Bind(&VideoScheduler::StopOnCaptureThread, this)); 129 } 130 131 void VideoScheduler::Pause(bool pause) { 132 if (!capture_task_runner_->BelongsToCurrentThread()) { 133 DCHECK(network_task_runner_->BelongsToCurrentThread()); 134 capture_task_runner_->PostTask( 135 FROM_HERE, base::Bind(&VideoScheduler::Pause, this, pause)); 136 return; 137 } 138 139 if (is_paused_ != pause) { 140 is_paused_ = pause; 141 142 // Restart captures if we're resuming and there are none scheduled. 143 if (!is_paused_ && capture_timer_ && !capture_timer_->IsRunning()) 144 CaptureNextFrame(); 145 } 146 } 147 148 void VideoScheduler::UpdateSequenceNumber(int64 sequence_number) { 149 if (!capture_task_runner_->BelongsToCurrentThread()) { 150 DCHECK(network_task_runner_->BelongsToCurrentThread()); 151 capture_task_runner_->PostTask( 152 FROM_HERE, base::Bind(&VideoScheduler::UpdateSequenceNumber, 153 this, sequence_number)); 154 return; 155 } 156 157 sequence_number_ = sequence_number; 158 } 159 160 // Private methods ----------------------------------------------------------- 161 162 VideoScheduler::~VideoScheduler() { 163 } 164 165 // Capturer thread ------------------------------------------------------------- 166 167 void VideoScheduler::StartOnCaptureThread() { 168 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 169 DCHECK(!capture_timer_); 170 171 // Start the capturer and let it notify us if cursor shape changes. 172 capturer_->SetMouseShapeObserver(this); 173 capturer_->Start(this); 174 175 capture_timer_.reset(new base::OneShotTimer<VideoScheduler>()); 176 177 // Capture first frame immedately. 178 CaptureNextFrame(); 179 } 180 181 void VideoScheduler::StopOnCaptureThread() { 182 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 183 184 // This doesn't deleted already captured frames, so encoder can keep using the 185 // frames that were captured previously. 186 capturer_.reset(); 187 188 // |capture_timer_| must be destroyed on the thread on which it is used. 189 capture_timer_.reset(); 190 } 191 192 void VideoScheduler::ScheduleNextCapture() { 193 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 194 195 capture_timer_->Start(FROM_HERE, 196 scheduler_.NextCaptureDelay(), 197 this, 198 &VideoScheduler::CaptureNextFrame); 199 } 200 201 void VideoScheduler::CaptureNextFrame() { 202 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 203 204 // If we are stopping (|capturer_| is NULL), or paused, then don't capture. 205 if (!capturer_ || is_paused_) 206 return; 207 208 // Make sure we have at most two outstanding recordings. We can simply return 209 // if we can't make a capture now, the next capture will be started by the 210 // end of an encode operation. 211 if (pending_frames_ >= kMaxPendingFrames || capture_pending_) { 212 did_skip_frame_ = true; 213 return; 214 } 215 216 did_skip_frame_ = false; 217 218 // At this point we are going to perform one capture so save the current time. 219 pending_frames_++; 220 DCHECK_LE(pending_frames_, kMaxPendingFrames); 221 222 // Before doing a capture schedule for the next one. 223 ScheduleNextCapture(); 224 225 capture_pending_ = true; 226 227 // And finally perform one capture. 228 capturer_->Capture(webrtc::DesktopRegion()); 229 } 230 231 void VideoScheduler::FrameCaptureCompleted() { 232 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 233 234 // Decrement the pending capture count. 235 pending_frames_--; 236 DCHECK_GE(pending_frames_, 0); 237 238 // If we've skipped a frame capture because too we had too many captures 239 // pending then schedule one now. 240 if (did_skip_frame_) 241 CaptureNextFrame(); 242 } 243 244 // Network thread -------------------------------------------------------------- 245 246 void VideoScheduler::SendVideoPacket(scoped_ptr<VideoPacket> packet) { 247 DCHECK(network_task_runner_->BelongsToCurrentThread()); 248 249 if (!video_stub_) 250 return; 251 252 video_stub_->ProcessVideoPacket( 253 packet.Pass(), base::Bind(&VideoScheduler::VideoFrameSentCallback, this)); 254 } 255 256 void VideoScheduler::VideoFrameSentCallback() { 257 DCHECK(network_task_runner_->BelongsToCurrentThread()); 258 259 if (!video_stub_) 260 return; 261 262 capture_task_runner_->PostTask( 263 FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this)); 264 } 265 266 void VideoScheduler::SendCursorShape( 267 scoped_ptr<protocol::CursorShapeInfo> cursor_shape) { 268 DCHECK(network_task_runner_->BelongsToCurrentThread()); 269 270 if (!cursor_stub_) 271 return; 272 273 cursor_stub_->SetCursorShape(*cursor_shape); 274 } 275 276 // Encoder thread -------------------------------------------------------------- 277 278 void VideoScheduler::EncodeFrame( 279 scoped_ptr<webrtc::DesktopFrame> frame, 280 int64 sequence_number) { 281 DCHECK(encode_task_runner_->BelongsToCurrentThread()); 282 283 // If there is nothing to encode then send an empty keep-alive packet. 284 if (!frame || frame->updated_region().is_empty()) { 285 scoped_ptr<VideoPacket> packet(new VideoPacket()); 286 packet->set_client_sequence_number(sequence_number); 287 network_task_runner_->PostTask( 288 FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this, 289 base::Passed(&packet))); 290 capture_task_runner_->DeleteSoon(FROM_HERE, frame.release()); 291 return; 292 } 293 294 scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame); 295 packet->set_client_sequence_number(sequence_number); 296 297 // Destroy the frame before sending |packet| because SendVideoPacket() may 298 // trigger another frame to be captured, and the screen capturer expects the 299 // old frame to be freed by then. 300 frame.reset(); 301 302 scheduler_.RecordEncodeTime( 303 base::TimeDelta::FromMilliseconds(packet->encode_time_ms())); 304 network_task_runner_->PostTask( 305 FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this, 306 base::Passed(&packet))); 307 } 308 309 } // namespace remoting 310
