| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 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/protocol/webrtc_frame_scheduler.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 #include <memory> | |
| 9 | |
| 10 #include "base/location.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/single_thread_task_runner.h" | |
| 13 #include "base/threading/thread_task_runner_handle.h" | |
| 14 #include "remoting/base/constants.h" | |
| 15 #include "remoting/proto/video.pb.h" | |
| 16 | |
| 17 namespace remoting { | |
| 18 namespace protocol { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // Default target bitrate in kbps | |
| 23 const int kDefaultTargetBitrateKbps = 1000; | |
| 24 | |
| 25 } // namespace | |
| 26 | |
| 27 // The frame scheduler currently uses a simple polling technique | |
| 28 // at 30 FPS to capture, encode and send frames over webrtc transport. | |
| 29 // An improved solution will use target bitrate feedback to pace out | |
| 30 // the capture rate. | |
| 31 WebrtcFrameScheduler::WebrtcFrameScheduler( | |
| 32 scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner, | |
| 33 std::unique_ptr<webrtc::DesktopCapturer> capturer, | |
| 34 WebrtcTransport* webrtc_transport, | |
| 35 std::unique_ptr<VideoEncoder> encoder) | |
| 36 : target_bitrate_kbps_(kDefaultTargetBitrateKbps), | |
| 37 main_task_runner_(base::ThreadTaskRunnerHandle::Get()), | |
| 38 encode_task_runner_(encode_task_runner), | |
| 39 capturer_(std::move(capturer)), | |
| 40 webrtc_transport_(webrtc_transport), | |
| 41 encoder_(std::move(encoder)), | |
| 42 weak_factory_(this) { | |
| 43 DCHECK(encode_task_runner_); | |
| 44 DCHECK(capturer_); | |
| 45 DCHECK(webrtc_transport_); | |
| 46 DCHECK(encoder_); | |
| 47 // Does not really start anything. Registers callback on this class. | |
| 48 capturer_->Start(this); | |
| 49 capture_timer_.reset(new base::RepeatingTimer()); | |
| 50 } | |
| 51 | |
| 52 WebrtcFrameScheduler::~WebrtcFrameScheduler() { | |
| 53 encode_task_runner_->DeleteSoon(FROM_HERE, encoder_.release()); | |
| 54 } | |
| 55 | |
| 56 void WebrtcFrameScheduler::Start() { | |
| 57 // Register for PLI requests. | |
| 58 webrtc_transport_->video_encoder_factory()->SetKeyFrameRequestCallback( | |
| 59 base::Bind(&WebrtcFrameScheduler::SetKeyFrameRequest, | |
| 60 base::Unretained(this))); | |
| 61 // Register for target bitrate notifications. | |
| 62 webrtc_transport_->video_encoder_factory()->SetTargetBitrateCallback( | |
| 63 base::Bind(&WebrtcFrameScheduler::SetTargetBitrate, | |
| 64 base::Unretained(this))); | |
| 65 } | |
| 66 | |
| 67 void WebrtcFrameScheduler::Stop() { | |
| 68 // Clear PLI request callback. | |
| 69 webrtc_transport_->video_encoder_factory()->SetKeyFrameRequestCallback( | |
| 70 base::Closure()); | |
| 71 webrtc_transport_->video_encoder_factory()->SetTargetBitrateCallback( | |
| 72 TargetBitrateCallback()); | |
| 73 // Cancel any pending encode. | |
| 74 task_tracker_.TryCancelAll(); | |
| 75 capture_timer_->Stop(); | |
| 76 } | |
| 77 | |
| 78 void WebrtcFrameScheduler::Pause(bool pause) { | |
| 79 if (pause) { | |
| 80 Stop(); | |
| 81 } else { | |
| 82 Start(); | |
| 83 } | |
| 84 } | |
| 85 | |
| 86 void WebrtcFrameScheduler::SetSizeCallback( | |
| 87 const VideoStream::SizeCallback& callback) { | |
| 88 size_callback_ = callback; | |
| 89 } | |
| 90 | |
| 91 void WebrtcFrameScheduler::SetKeyFrameRequest() { | |
| 92 VLOG(1) << "Request key frame"; | |
| 93 base::AutoLock lock(lock_); | |
| 94 key_frame_request_ = true; | |
| 95 if (!received_first_frame_request_) { | |
| 96 received_first_frame_request_ = true; | |
| 97 main_task_runner_->PostTask( | |
| 98 FROM_HERE, base::Bind(&WebrtcFrameScheduler::StartCaptureTimer, | |
| 99 weak_factory_.GetWeakPtr())); | |
| 100 } | |
| 101 } | |
| 102 | |
| 103 void WebrtcFrameScheduler::StartCaptureTimer() { | |
| 104 capture_timer_->Start(FROM_HERE, base::TimeDelta::FromSeconds(1) / 30, this, | |
| 105 &WebrtcFrameScheduler::CaptureNextFrame); | |
| 106 } | |
| 107 | |
| 108 void WebrtcFrameScheduler::SetTargetBitrate(int target_bitrate_kbps) { | |
| 109 VLOG(1) << "Set Target bitrate " << target_bitrate_kbps; | |
| 110 base::AutoLock lock(lock_); | |
| 111 target_bitrate_kbps_ = target_bitrate_kbps; | |
| 112 } | |
| 113 | |
| 114 bool WebrtcFrameScheduler::ClearAndGetKeyFrameRequest() { | |
| 115 base::AutoLock lock(lock_); | |
| 116 bool key_frame_request = key_frame_request_; | |
| 117 key_frame_request_ = false; | |
| 118 return key_frame_request; | |
| 119 } | |
| 120 | |
| 121 void WebrtcFrameScheduler::OnCaptureResult( | |
| 122 webrtc::DesktopCapturer::Result result, | |
| 123 std::unique_ptr<webrtc::DesktopFrame> frame) { | |
| 124 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 125 | |
| 126 base::TimeTicks captured_ticks = base::TimeTicks::Now(); | |
| 127 int64_t capture_timestamp_ms = | |
| 128 (captured_ticks - base::TimeTicks()).InMilliseconds(); | |
| 129 capture_pending_ = false; | |
| 130 | |
| 131 // TODO(sergeyu): Handle ERROR_PERMANENT result here. | |
| 132 | |
| 133 if (encode_pending_) { | |
| 134 // TODO(isheriff): consider queuing here | |
| 135 VLOG(1) << "Dropping captured frame since encoder is still busy"; | |
| 136 return; | |
| 137 } | |
| 138 | |
| 139 last_capture_completed_ticks_ = captured_ticks; | |
| 140 | |
| 141 webrtc::DesktopVector dpi = | |
| 142 frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi) | |
| 143 : frame->dpi(); | |
| 144 | |
| 145 if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) { | |
| 146 frame_size_ = frame->size(); | |
| 147 frame_dpi_ = dpi; | |
| 148 if (!size_callback_.is_null()) | |
| 149 size_callback_.Run(frame_size_, frame_dpi_); | |
| 150 } | |
| 151 encode_pending_ = true; | |
| 152 task_tracker_.PostTaskAndReplyWithResult( | |
| 153 encode_task_runner_.get(), FROM_HERE, | |
| 154 base::Bind(&WebrtcFrameScheduler::EncodeFrame, encoder_.get(), | |
| 155 base::Passed(&frame), target_bitrate_kbps_, | |
| 156 ClearAndGetKeyFrameRequest(), capture_timestamp_ms), | |
| 157 base::Bind(&WebrtcFrameScheduler::OnFrameEncoded, | |
| 158 weak_factory_.GetWeakPtr())); | |
| 159 } | |
| 160 | |
| 161 void WebrtcFrameScheduler::CaptureNextFrame() { | |
| 162 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 163 | |
| 164 if (capture_pending_ || encode_pending_) { | |
| 165 VLOG(1) << "Capture/encode still pending.."; | |
| 166 return; | |
| 167 } | |
| 168 | |
| 169 capture_pending_ = true; | |
| 170 VLOG(1) << "Capture next frame after " | |
| 171 << (base::TimeTicks::Now() - last_capture_started_ticks_) | |
| 172 .InMilliseconds(); | |
| 173 last_capture_started_ticks_ = base::TimeTicks::Now(); | |
| 174 capturer_->Capture(webrtc::DesktopRegion()); | |
| 175 } | |
| 176 | |
| 177 // static | |
| 178 std::unique_ptr<VideoPacket> WebrtcFrameScheduler::EncodeFrame( | |
| 179 VideoEncoder* encoder, | |
| 180 std::unique_ptr<webrtc::DesktopFrame> frame, | |
| 181 uint32_t target_bitrate_kbps, | |
| 182 bool key_frame_request, | |
| 183 int64_t capture_time_ms) { | |
| 184 uint32_t flags = 0; | |
| 185 if (key_frame_request) | |
| 186 flags |= VideoEncoder::REQUEST_KEY_FRAME; | |
| 187 | |
| 188 base::TimeTicks current = base::TimeTicks::Now(); | |
| 189 encoder->UpdateTargetBitrate(target_bitrate_kbps); | |
| 190 std::unique_ptr<VideoPacket> packet = encoder->Encode(*frame, flags); | |
| 191 if (!packet) | |
| 192 return nullptr; | |
| 193 // TODO(isheriff): Note that while VideoPacket capture time is supposed | |
| 194 // to be capture duration, we (ab)use it for capture timestamp here. This | |
| 195 // will go away when we move away from VideoPacket. | |
| 196 packet->set_capture_time_ms(capture_time_ms); | |
| 197 | |
| 198 VLOG(1) << "Encode duration " | |
| 199 << (base::TimeTicks::Now() - current).InMilliseconds() | |
| 200 << " payload size " << packet->data().size(); | |
| 201 return packet; | |
| 202 } | |
| 203 | |
| 204 void WebrtcFrameScheduler::OnFrameEncoded(std::unique_ptr<VideoPacket> packet) { | |
| 205 DCHECK(thread_checker_.CalledOnValidThread()); | |
| 206 encode_pending_ = false; | |
| 207 if (!packet) | |
| 208 return; | |
| 209 base::TimeTicks current = base::TimeTicks::Now(); | |
| 210 float encoded_bits = packet->data().size() * 8.0; | |
| 211 | |
| 212 // Simplistic adaptation of frame polling in the range 5 FPS to 30 FPS. | |
| 213 uint32_t next_sched_ms = std::max( | |
| 214 33, std::min(static_cast<int>(encoded_bits / target_bitrate_kbps_), 200)); | |
| 215 if (webrtc_transport_->video_encoder_factory()->SendEncodedFrame( | |
| 216 std::move(packet)) >= 0) { | |
| 217 VLOG(1) << " Send duration " | |
| 218 << (base::TimeTicks::Now() - current).InMilliseconds() | |
| 219 << "next sched " << next_sched_ms; | |
| 220 } else { | |
| 221 LOG(ERROR) << "SendEncodedFrame() failed"; | |
| 222 } | |
| 223 capture_timer_->Start(FROM_HERE, | |
| 224 base::TimeDelta::FromMilliseconds(next_sched_ms), this, | |
| 225 &WebrtcFrameScheduler::CaptureNextFrame); | |
| 226 } | |
| 227 | |
| 228 } // namespace protocol | |
| 229 } // namespace remoting | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2079253003:
Move frame scheduling logic from WebrtcFrameScheduler to WebrtcVideoStream. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master