Index: remoting/host/capture_scheduler.cc |
diff --git a/remoting/host/capture_scheduler.cc b/remoting/host/capture_scheduler.cc |
deleted file mode 100644 |
index 556c20763c6e54534cb27dabdc4ab173970b8c7d..0000000000000000000000000000000000000000 |
--- a/remoting/host/capture_scheduler.cc |
+++ /dev/null |
@@ -1,181 +0,0 @@ |
-// Copyright (c) 2011 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/capture_scheduler.h" |
- |
-#include <algorithm> |
- |
-#include "base/logging.h" |
-#include "base/sys_info.h" |
-#include "base/time/default_tick_clock.h" |
-#include "base/time/time.h" |
-#include "remoting/proto/video.pb.h" |
- |
-namespace { |
- |
-// Number of samples to average the most recent capture and encode time |
-// over. |
-const int kStatisticsWindow = 3; |
- |
-// The hard limit is 30fps or 33ms per recording cycle. |
-const int64 kDefaultMinimumIntervalMs = 33; |
- |
-// Controls how much CPU time we can use for encode and capture. |
-// Range of this value is between 0 to 1. 0 means using 0% of of all CPUs |
-// available while 1 means using 100% of all CPUs available. |
-const double kRecordingCpuConsumption = 0.5; |
- |
-// Maximum number of captured frames in the encoding queue. Currently capturer |
-// implementations do not allow to keep more than 2 DesktopFrame objects. |
-static const int kMaxFramesInEncodingQueue = 2; |
- |
-// Maximum number of unacknowledged frames. Ignored if the client doesn't |
-// support ACKs. This value was chosen experimentally, using synthetic |
-// performance tests (see ProtocolPerfTest), to maximize frame rate, while |
-// keeping round-trip latency low. |
-static const int kMaxUnacknowledgedFrames = 4; |
- |
-} // namespace |
- |
-namespace remoting { |
- |
-// We assume that the number of available cores is constant. |
-CaptureScheduler::CaptureScheduler(const base::Closure& capture_closure) |
- : capture_closure_(capture_closure), |
- tick_clock_(new base::DefaultTickClock()), |
- capture_timer_(new base::Timer(false, false)), |
- minimum_interval_( |
- base::TimeDelta::FromMilliseconds(kDefaultMinimumIntervalMs)), |
- num_of_processors_(base::SysInfo::NumberOfProcessors()), |
- capture_time_(kStatisticsWindow), |
- encode_time_(kStatisticsWindow), |
- num_encoding_frames_(0), |
- num_unacknowledged_frames_(0), |
- capture_pending_(false), |
- is_paused_(false), |
- next_frame_id_(0) { |
- DCHECK(num_of_processors_); |
-} |
- |
-CaptureScheduler::~CaptureScheduler() { |
-} |
- |
-void CaptureScheduler::Start() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- ScheduleNextCapture(); |
-} |
- |
-void CaptureScheduler::Pause(bool pause) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- if (is_paused_ != pause) { |
- is_paused_ = pause; |
- |
- if (is_paused_) { |
- capture_timer_->Stop(); |
- } else { |
- ScheduleNextCapture(); |
- } |
- } |
-} |
- |
-void CaptureScheduler::OnCaptureCompleted() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- capture_pending_ = false; |
- capture_time_.Record( |
- (tick_clock_->NowTicks() - last_capture_started_time_).InMilliseconds()); |
- |
- ++num_encoding_frames_; |
- |
- ScheduleNextCapture(); |
-} |
- |
-void CaptureScheduler::OnFrameEncoded(VideoPacket* packet) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- // Set packet_id for the outgoing packet. |
- packet->set_frame_id(next_frame_id_); |
- ++next_frame_id_; |
- |
- // Update internal stats. |
- encode_time_.Record(packet->encode_time_ms()); |
- |
- --num_encoding_frames_; |
- ++num_unacknowledged_frames_; |
- |
- ScheduleNextCapture(); |
-} |
- |
-void CaptureScheduler::OnFrameSent() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- ScheduleNextCapture(); |
-} |
- |
-void CaptureScheduler::ProcessVideoAck(scoped_ptr<VideoAck> video_ack) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- --num_unacknowledged_frames_; |
- DCHECK_GE(num_unacknowledged_frames_, 0); |
- |
- ScheduleNextCapture(); |
-} |
- |
-void CaptureScheduler::SetTickClockForTest( |
- scoped_ptr<base::TickClock> tick_clock) { |
- tick_clock_ = tick_clock.Pass(); |
-} |
- |
-void CaptureScheduler::SetTimerForTest(scoped_ptr<base::Timer> timer) { |
- capture_timer_ = timer.Pass(); |
-} |
- |
-void CaptureScheduler::SetNumOfProcessorsForTest(int num_of_processors) { |
- num_of_processors_ = num_of_processors; |
-} |
- |
-void CaptureScheduler::ScheduleNextCapture() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- if (is_paused_ || capture_pending_ || |
- num_encoding_frames_ >= kMaxFramesInEncodingQueue) { |
- return; |
- } |
- |
- if (num_encoding_frames_ + num_unacknowledged_frames_ >= |
- kMaxUnacknowledgedFrames) { |
- return; |
- } |
- |
- // Delay by an amount chosen such that if capture and encode times |
- // continue to follow the averages, then we'll consume the target |
- // fraction of CPU across all cores. |
- base::TimeDelta delay = |
- std::max(minimum_interval_, |
- base::TimeDelta::FromMilliseconds( |
- (capture_time_.Average() + encode_time_.Average()) / |
- (kRecordingCpuConsumption * num_of_processors_))); |
- |
- // Account for the time that has passed since the last capture. |
- delay = std::max(base::TimeDelta(), delay - (tick_clock_->NowTicks() - |
- last_capture_started_time_)); |
- |
- capture_timer_->Start( |
- FROM_HERE, delay, |
- base::Bind(&CaptureScheduler::CaptureNextFrame, base::Unretained(this))); |
-} |
- |
-void CaptureScheduler::CaptureNextFrame() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- DCHECK(!is_paused_); |
- DCHECK(!capture_pending_); |
- |
- capture_pending_ = true; |
- last_capture_started_time_ = tick_clock_->NowTicks(); |
- capture_closure_.Run(); |
-} |
- |
-} // namespace remoting |