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/video_stub.h" 23 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h" 24 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor_shape.h" 25 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h" 26 27 namespace remoting { 28 29 // Maximum number of frames that can be processed simultaneously. 30 // TODO(hclam): Move this value to CaptureScheduler. 31 static const int kMaxPendingFrames = 2; 32 33 // Interval between empty keep-alive frames. These frames are sent only 34 // when there are no real video frames being sent. To prevent PseudoTCP from 35 // resetting congestion window this value must be smaller that then the minimum 36 // RTO used in PseudoTCP, which is 250ms. 37 static const int kKeepAlivePacketIntervalMs = 200; 38 39 VideoScheduler::VideoScheduler( 40 scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner, 41 scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner, 42 scoped_refptr<base::SingleThreadTaskRunner> network_task_runner, 43 scoped_ptr<webrtc::ScreenCapturer> capturer, 44 scoped_ptr<VideoEncoder> encoder, 45 protocol::CursorShapeStub* cursor_stub, 46 protocol::VideoStub* video_stub) 47 : capture_task_runner_(capture_task_runner), 48 encode_task_runner_(encode_task_runner), 49 network_task_runner_(network_task_runner), 50 capturer_(capturer.Pass()), 51 encoder_(encoder.Pass()), 52 cursor_stub_(cursor_stub), 53 video_stub_(video_stub), 54 pending_frames_(0), 55 capture_pending_(false), 56 did_skip_frame_(false), 57 is_paused_(false), 58 sequence_number_(0) { 59 DCHECK(network_task_runner_->BelongsToCurrentThread()); 60 DCHECK(capturer_); 61 DCHECK(encoder_); 62 DCHECK(cursor_stub_); 63 DCHECK(video_stub_); 64 } 65 66 // Public methods -------------------------------------------------------------- 67 68 webrtc::SharedMemory* VideoScheduler::CreateSharedMemory(size_t size) { 69 return NULL; 70 } 71 72 void VideoScheduler::OnCaptureCompleted(webrtc::DesktopFrame* frame) { 73 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 74 75 capture_pending_ = false; 76 77 scoped_ptr<webrtc::DesktopFrame> owned_frame(frame); 78 79 if (owned_frame) { 80 scheduler_.RecordCaptureTime( 81 base::TimeDelta::FromMilliseconds(owned_frame->capture_time_ms())); 82 } 83 84 // Even when |frame| is NULL we still need to post it to the encode thread 85 // to make sure frames are freed in the same order they are received and 86 // that we don't start capturing frame n+2 before frame n is freed. 87 encode_task_runner_->PostTask( 88 FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, 89 base::Passed(&owned_frame), sequence_number_)); 90 91 // If a frame was skipped, try to capture it again. 92 if (did_skip_frame_) { 93 capture_task_runner_->PostTask( 94 FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this)); 95 } 96 } 97 98 void VideoScheduler::OnCursorShapeChanged( 99 webrtc::MouseCursorShape* cursor_shape) { 100 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 101 102 scoped_ptr<webrtc::MouseCursorShape> owned_cursor(cursor_shape); 103 104 // Do nothing if the scheduler is being stopped. 105 if (!capturer_) 106 return; 107 108 scoped_ptr<protocol::CursorShapeInfo> cursor_proto( 109 new protocol::CursorShapeInfo()); 110 cursor_proto->set_width(cursor_shape->size.width()); 111 cursor_proto->set_height(cursor_shape->size.height()); 112 cursor_proto->set_hotspot_x(cursor_shape->hotspot.x()); 113 cursor_proto->set_hotspot_y(cursor_shape->hotspot.y()); 114 cursor_proto->set_data(cursor_shape->data); 115 116 network_task_runner_->PostTask( 117 FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this, 118 base::Passed(&cursor_proto))); 119 } 120 121 void VideoScheduler::Start() { 122 DCHECK(network_task_runner_->BelongsToCurrentThread()); 123 124 capture_task_runner_->PostTask( 125 FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this)); 126 } 127 128 void VideoScheduler::Stop() { 129 DCHECK(network_task_runner_->BelongsToCurrentThread()); 130 131 // Clear stubs to prevent further updates reaching the client. 132 cursor_stub_ = NULL; 133 video_stub_ = NULL; 134 135 keep_alive_timer_.reset(); 136 137 capture_task_runner_->PostTask( 138 FROM_HERE, base::Bind(&VideoScheduler::StopOnCaptureThread, this)); 139 } 140 141 void VideoScheduler::Pause(bool pause) { 142 if (!capture_task_runner_->BelongsToCurrentThread()) { 143 DCHECK(network_task_runner_->BelongsToCurrentThread()); 144 capture_task_runner_->PostTask( 145 FROM_HERE, base::Bind(&VideoScheduler::Pause, this, pause)); 146 return; 147 } 148 149 if (is_paused_ != pause) { 150 is_paused_ = pause; 151 152 // Restart captures if we're resuming and there are none scheduled. 153 if (!is_paused_ && capture_timer_ && !capture_timer_->IsRunning()) 154 CaptureNextFrame(); 155 } 156 } 157 158 void VideoScheduler::UpdateSequenceNumber(int64 sequence_number) { 159 if (!capture_task_runner_->BelongsToCurrentThread()) { 160 DCHECK(network_task_runner_->BelongsToCurrentThread()); 161 capture_task_runner_->PostTask( 162 FROM_HERE, base::Bind(&VideoScheduler::UpdateSequenceNumber, 163 this, sequence_number)); 164 return; 165 } 166 167 sequence_number_ = sequence_number; 168 } 169 170 void VideoScheduler::SetLosslessEncode(bool want_lossless) { 171 if (!encode_task_runner_->BelongsToCurrentThread()) { 172 DCHECK(network_task_runner_->BelongsToCurrentThread()); 173 encode_task_runner_->PostTask( 174 FROM_HERE, base::Bind(&VideoScheduler::SetLosslessEncode, 175 this, want_lossless)); 176 return; 177 } 178 179 encoder_->SetLosslessEncode(want_lossless); 180 } 181 182 void VideoScheduler::SetLosslessColor(bool want_lossless) { 183 if (!encode_task_runner_->BelongsToCurrentThread()) { 184 DCHECK(network_task_runner_->BelongsToCurrentThread()); 185 encode_task_runner_->PostTask( 186 FROM_HERE, base::Bind(&VideoScheduler::SetLosslessColor, 187 this, want_lossless)); 188 return; 189 } 190 191 encoder_->SetLosslessColor(want_lossless); 192 } 193 194 // Private methods ----------------------------------------------------------- 195 196 VideoScheduler::~VideoScheduler() { 197 } 198 199 // Capturer thread ------------------------------------------------------------- 200 201 void VideoScheduler::StartOnCaptureThread() { 202 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 203 DCHECK(!capture_timer_); 204 205 // Start the capturer and let it notify us if cursor shape changes. 206 capturer_->SetMouseShapeObserver(this); 207 capturer_->Start(this); 208 209 capture_timer_.reset(new base::OneShotTimer<VideoScheduler>()); 210 keep_alive_timer_.reset(new base::DelayTimer<VideoScheduler>( 211 FROM_HERE, base::TimeDelta::FromMilliseconds(kKeepAlivePacketIntervalMs), 212 this, &VideoScheduler::SendKeepAlivePacket)); 213 214 // Capture first frame immedately. 215 CaptureNextFrame(); 216 } 217 218 void VideoScheduler::StopOnCaptureThread() { 219 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 220 221 // This doesn't deleted already captured frames, so encoder can keep using the 222 // frames that were captured previously. 223 capturer_.reset(); 224 225 // |capture_timer_| must be destroyed on the thread on which it is used. 226 capture_timer_.reset(); 227 } 228 229 void VideoScheduler::ScheduleNextCapture() { 230 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 231 232 capture_timer_->Start(FROM_HERE, 233 scheduler_.NextCaptureDelay(), 234 this, 235 &VideoScheduler::CaptureNextFrame); 236 } 237 238 void VideoScheduler::CaptureNextFrame() { 239 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 240 241 // If we are stopping (|capturer_| is NULL), or paused, then don't capture. 242 if (!capturer_ || is_paused_) 243 return; 244 245 // Make sure we have at most two outstanding recordings. We can simply return 246 // if we can't make a capture now, the next capture will be started by the 247 // end of an encode operation. 248 if (pending_frames_ >= kMaxPendingFrames || capture_pending_) { 249 did_skip_frame_ = true; 250 return; 251 } 252 253 did_skip_frame_ = false; 254 255 // At this point we are going to perform one capture so save the current time. 256 pending_frames_++; 257 DCHECK_LE(pending_frames_, kMaxPendingFrames); 258 259 // Before doing a capture schedule for the next one. 260 ScheduleNextCapture(); 261 262 capture_pending_ = true; 263 264 // And finally perform one capture. 265 capturer_->Capture(webrtc::DesktopRegion()); 266 } 267 268 void VideoScheduler::FrameCaptureCompleted() { 269 DCHECK(capture_task_runner_->BelongsToCurrentThread()); 270 271 // Decrement the pending capture count. 272 pending_frames_--; 273 DCHECK_GE(pending_frames_, 0); 274 275 // If we've skipped a frame capture because too we had too many captures 276 // pending then schedule one now. 277 if (did_skip_frame_) 278 CaptureNextFrame(); 279 } 280 281 // Network thread -------------------------------------------------------------- 282 283 void VideoScheduler::SendVideoPacket(scoped_ptr<VideoPacket> packet) { 284 DCHECK(network_task_runner_->BelongsToCurrentThread()); 285 286 if (!video_stub_) 287 return; 288 289 video_stub_->ProcessVideoPacket( 290 packet.Pass(), base::Bind(&VideoScheduler::OnVideoPacketSent, this)); 291 } 292 293 void VideoScheduler::OnVideoPacketSent() { 294 DCHECK(network_task_runner_->BelongsToCurrentThread()); 295 296 if (!video_stub_) 297 return; 298 299 keep_alive_timer_->Reset(); 300 301 capture_task_runner_->PostTask( 302 FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this)); 303 } 304 305 void VideoScheduler::SendKeepAlivePacket() { 306 DCHECK(network_task_runner_->BelongsToCurrentThread()); 307 308 if (!video_stub_) 309 return; 310 311 video_stub_->ProcessVideoPacket( 312 scoped_ptr<VideoPacket>(new VideoPacket()), 313 base::Bind(&VideoScheduler::OnKeepAlivePacketSent, this)); 314 } 315 316 void VideoScheduler::OnKeepAlivePacketSent() { 317 DCHECK(network_task_runner_->BelongsToCurrentThread()); 318 319 if (keep_alive_timer_) 320 keep_alive_timer_->Reset(); 321 } 322 323 void VideoScheduler::SendCursorShape( 324 scoped_ptr<protocol::CursorShapeInfo> cursor_shape) { 325 DCHECK(network_task_runner_->BelongsToCurrentThread()); 326 327 if (!cursor_stub_) 328 return; 329 330 cursor_stub_->SetCursorShape(*cursor_shape); 331 } 332 333 // Encoder thread -------------------------------------------------------------- 334 335 void VideoScheduler::EncodeFrame( 336 scoped_ptr<webrtc::DesktopFrame> frame, 337 int64 sequence_number) { 338 DCHECK(encode_task_runner_->BelongsToCurrentThread()); 339 340 // Drop the frame if there were no changes. 341 if (!frame || frame->updated_region().is_empty()) { 342 capture_task_runner_->DeleteSoon(FROM_HERE, frame.release()); 343 capture_task_runner_->PostTask( 344 FROM_HERE, base::Bind(&VideoScheduler::FrameCaptureCompleted, this)); 345 return; 346 } 347 348 scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame); 349 packet->set_client_sequence_number(sequence_number); 350 351 // Destroy the frame before sending |packet| because SendVideoPacket() may 352 // trigger another frame to be captured, and the screen capturer expects the 353 // old frame to be freed by then. 354 frame.reset(); 355 356 scheduler_.RecordEncodeTime( 357 base::TimeDelta::FromMilliseconds(packet->encode_time_ms())); 358 network_task_runner_->PostTask( 359 FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this, 360 base::Passed(&packet))); 361 } 362 363 } // namespace remoting 364
