OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/protocol/webrtc_dummy_video_encoder.h" | 5 #include "remoting/protocol/webrtc_dummy_video_encoder.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
| 10 #include "base/bind.h" |
10 #include "base/callback.h" | 11 #include "base/callback.h" |
11 #include "base/logging.h" | 12 #include "base/logging.h" |
12 #include "base/memory/ptr_util.h" | 13 #include "base/memory/ptr_util.h" |
13 #include "base/synchronization/lock.h" | 14 #include "base/synchronization/lock.h" |
| 15 #include "base/threading/thread_task_runner_handle.h" |
| 16 #include "remoting/protocol/video_channel_state_observer.h" |
14 | 17 |
15 namespace remoting { | 18 namespace remoting { |
16 namespace protocol { | 19 namespace protocol { |
17 | 20 |
18 WebrtcDummyVideoEncoder::WebrtcDummyVideoEncoder(webrtc::VideoCodecType codec) | 21 WebrtcDummyVideoEncoder::WebrtcDummyVideoEncoder( |
19 : state_(kUninitialized), video_codec_type_(codec) { | 22 scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, |
20 VLOG(1) << "video codecType " << video_codec_type_; | 23 base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer) |
21 } | 24 : main_task_runner_(main_task_runner), |
| 25 state_(kUninitialized), |
| 26 video_channel_state_observer_(video_channel_state_observer) {} |
22 | 27 |
23 WebrtcDummyVideoEncoder::~WebrtcDummyVideoEncoder() {} | 28 WebrtcDummyVideoEncoder::~WebrtcDummyVideoEncoder() {} |
24 | 29 |
25 int32_t WebrtcDummyVideoEncoder::InitEncode( | 30 int32_t WebrtcDummyVideoEncoder::InitEncode( |
26 const webrtc::VideoCodec* codec_settings, | 31 const webrtc::VideoCodec* codec_settings, |
27 int32_t number_of_cores, | 32 int32_t number_of_cores, |
28 size_t max_payload_size) { | 33 size_t max_payload_size) { |
| 34 DCHECK(codec_settings); |
29 base::AutoLock lock(lock_); | 35 base::AutoLock lock(lock_); |
30 DCHECK(codec_settings); | 36 int stream_count = codec_settings->numberOfSimulcastStreams; |
31 VLOG(1) << "video codecType " << codec_settings->codecType << " width " | |
32 << codec_settings->width << " height " << codec_settings->height | |
33 << " startBitrate " << codec_settings->startBitrate << " maxBitrate " | |
34 << codec_settings->maxBitrate << " minBitrate " | |
35 << codec_settings->minBitrate << " targetBitrate " | |
36 << codec_settings->targetBitrate << " maxFramerate " | |
37 << codec_settings->maxFramerate; | |
38 | |
39 int streamCount = codec_settings->numberOfSimulcastStreams; | |
40 // Validate request is to support a single stream. | 37 // Validate request is to support a single stream. |
41 if (streamCount > 1) { | 38 if (stream_count > 1) { |
42 for (int i = 0; i < streamCount; ++i) { | 39 for (int i = 0; i < stream_count; ++i) { |
43 if (codec_settings->simulcastStream[i].maxBitrate != 0) { | 40 if (codec_settings->simulcastStream[i].maxBitrate != 0) { |
44 LOG(ERROR) << "Simulcast unsupported"; | 41 LOG(ERROR) << "Simulcast unsupported"; |
45 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; | 42 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
46 } | 43 } |
47 } | 44 } |
48 } | 45 } |
49 state_ = kInitialized; | 46 state_ = kInitialized; |
50 return WEBRTC_VIDEO_CODEC_OK; | 47 return WEBRTC_VIDEO_CODEC_OK; |
51 } | 48 } |
52 | 49 |
53 int32_t WebrtcDummyVideoEncoder::RegisterEncodeCompleteCallback( | 50 int32_t WebrtcDummyVideoEncoder::RegisterEncodeCompleteCallback( |
54 webrtc::EncodedImageCallback* callback) { | 51 webrtc::EncodedImageCallback* callback) { |
| 52 DCHECK(callback); |
55 base::AutoLock lock(lock_); | 53 base::AutoLock lock(lock_); |
56 DCHECK(callback); | |
57 encoded_callback_ = callback; | 54 encoded_callback_ = callback; |
58 return WEBRTC_VIDEO_CODEC_OK; | 55 return WEBRTC_VIDEO_CODEC_OK; |
59 } | 56 } |
60 | 57 |
61 int32_t WebrtcDummyVideoEncoder::Release() { | 58 int32_t WebrtcDummyVideoEncoder::Release() { |
62 base::AutoLock lock(lock_); | 59 base::AutoLock lock(lock_); |
63 encoded_callback_ = nullptr; | 60 encoded_callback_ = nullptr; |
64 return WEBRTC_VIDEO_CODEC_OK; | 61 return WEBRTC_VIDEO_CODEC_OK; |
65 } | 62 } |
66 | 63 |
67 int32_t WebrtcDummyVideoEncoder::Encode( | 64 int32_t WebrtcDummyVideoEncoder::Encode( |
68 const webrtc::VideoFrame& frame, | 65 const webrtc::VideoFrame& frame, |
69 const webrtc::CodecSpecificInfo* codec_specific_info, | 66 const webrtc::CodecSpecificInfo* codec_specific_info, |
70 const std::vector<webrtc::FrameType>* frame_types) { | 67 const std::vector<webrtc::FrameType>* frame_types) { |
71 base::AutoLock lock(lock_); | 68 // WebrtcDummyVideoCapturer doesn't generate any video frames, so Encode() can |
72 if (!key_frame_request_.is_null()) | 69 // be called only from VCMGenericEncoder::RequestFrame() to request a key |
73 key_frame_request_.Run(); | 70 // frame. |
| 71 main_task_runner_->PostTask( |
| 72 FROM_HERE, base::Bind(&VideoChannelStateObserver::OnKeyFrameRequested, |
| 73 video_channel_state_observer_)); |
74 return WEBRTC_VIDEO_CODEC_OK; | 74 return WEBRTC_VIDEO_CODEC_OK; |
75 } | 75 } |
76 | 76 |
77 int32_t WebrtcDummyVideoEncoder::SetChannelParameters(uint32_t packet_loss, | 77 int32_t WebrtcDummyVideoEncoder::SetChannelParameters(uint32_t packet_loss, |
78 int64_t rtt) { | 78 int64_t rtt) { |
79 VLOG(1) << "WebrtcDummyVideoEncoder::SetChannelParameters " | 79 main_task_runner_->PostTask( |
80 << "loss:RTT " << packet_loss << ":" << rtt; | 80 FROM_HERE, base::Bind(&VideoChannelStateObserver::OnChannelParameters, |
81 // Unused right now. | 81 video_channel_state_observer_, packet_loss, |
| 82 base::TimeDelta::FromMilliseconds(rtt))); |
82 return WEBRTC_VIDEO_CODEC_OK; | 83 return WEBRTC_VIDEO_CODEC_OK; |
83 } | 84 } |
84 | 85 |
85 int32_t WebrtcDummyVideoEncoder::SetRates(uint32_t bitrate, | 86 int32_t WebrtcDummyVideoEncoder::SetRates(uint32_t bitrate, |
86 uint32_t framerate) { | 87 uint32_t framerate) { |
87 VLOG(1) << "WebrtcDummyVideoEncoder::SetRates bitrate:framerate " << bitrate | 88 main_task_runner_->PostTask( |
88 << ":" << framerate; | 89 FROM_HERE, base::Bind(&VideoChannelStateObserver::OnTargetBitrateChanged, |
89 if (!target_bitrate_cb_.is_null()) | 90 video_channel_state_observer_, bitrate)); |
90 target_bitrate_cb_.Run(bitrate); | |
91 // framerate is not expected to be valid given we never report captured | 91 // framerate is not expected to be valid given we never report captured |
92 // frames | 92 // frames. |
93 return WEBRTC_VIDEO_CODEC_OK; | 93 return WEBRTC_VIDEO_CODEC_OK; |
94 } | 94 } |
95 | 95 |
96 webrtc::EncodedImageCallback::Result WebrtcDummyVideoEncoder::SendEncodedFrame( | 96 webrtc::EncodedImageCallback::Result WebrtcDummyVideoEncoder::SendEncodedFrame( |
97 const WebrtcVideoEncoder::EncodedFrame& frame, | 97 const WebrtcVideoEncoder::EncodedFrame& frame, |
98 base::TimeTicks capture_time) { | 98 base::TimeTicks capture_time) { |
| 99 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
99 uint8_t* buffer = | 100 uint8_t* buffer = |
100 reinterpret_cast<uint8_t*>(const_cast<char*>(frame.data.data())); | 101 reinterpret_cast<uint8_t*>(const_cast<char*>(frame.data.data())); |
101 size_t buffer_size = frame.data.size(); | 102 size_t buffer_size = frame.data.size(); |
102 base::AutoLock lock(lock_); | 103 base::AutoLock lock(lock_); |
103 if (state_ == kUninitialized) { | 104 if (state_ == kUninitialized) { |
104 LOG(ERROR) << "encoder interface uninitialized"; | 105 LOG(ERROR) << "encoder interface uninitialized"; |
105 return webrtc::EncodedImageCallback::Result( | 106 return webrtc::EncodedImageCallback::Result( |
106 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); | 107 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
107 } | 108 } |
108 | 109 |
(...skipping 24 matching lines...) Expand all Loading... |
133 header.VerifyAndAllocateFragmentationHeader(1); | 134 header.VerifyAndAllocateFragmentationHeader(1); |
134 header.fragmentationOffset[0] = 0; | 135 header.fragmentationOffset[0] = 0; |
135 header.fragmentationLength[0] = buffer_size; | 136 header.fragmentationLength[0] = buffer_size; |
136 header.fragmentationPlType[0] = 0; | 137 header.fragmentationPlType[0] = 0; |
137 header.fragmentationTimeDiff[0] = 0; | 138 header.fragmentationTimeDiff[0] = 0; |
138 | 139 |
139 return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info, | 140 return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info, |
140 &header); | 141 &header); |
141 } | 142 } |
142 | 143 |
143 void WebrtcDummyVideoEncoder::SetKeyFrameRequestCallback( | 144 WebrtcDummyVideoEncoderFactory::WebrtcDummyVideoEncoderFactory() |
144 const base::Closure& key_frame_request) { | 145 : main_task_runner_(base::ThreadTaskRunnerHandle::Get()) { |
145 base::AutoLock lock(lock_); | |
146 key_frame_request_ = key_frame_request; | |
147 } | |
148 | |
149 void WebrtcDummyVideoEncoder::SetTargetBitrateCallback( | |
150 const TargetBitrateCallback& target_bitrate_cb) { | |
151 base::AutoLock lock(lock_); | |
152 target_bitrate_cb_ = target_bitrate_cb; | |
153 } | |
154 | |
155 WebrtcDummyVideoEncoderFactory::WebrtcDummyVideoEncoderFactory() { | |
156 // TODO(isheriff): These do not really affect anything internally | 146 // TODO(isheriff): These do not really affect anything internally |
157 // in webrtc. | 147 // in webrtc. |
158 codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec( | 148 codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec( |
159 webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30)); | 149 webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30)); |
160 } | 150 } |
161 | 151 |
162 WebrtcDummyVideoEncoderFactory::~WebrtcDummyVideoEncoderFactory() { | 152 WebrtcDummyVideoEncoderFactory::~WebrtcDummyVideoEncoderFactory() { |
163 DCHECK(encoders_.empty()); | 153 DCHECK(encoders_.empty()); |
164 } | 154 } |
165 | 155 |
166 webrtc::VideoEncoder* WebrtcDummyVideoEncoderFactory::CreateVideoEncoder( | 156 webrtc::VideoEncoder* WebrtcDummyVideoEncoderFactory::CreateVideoEncoder( |
167 webrtc::VideoCodecType type) { | 157 webrtc::VideoCodecType type) { |
168 VLOG(2) << "WebrtcDummyVideoEncoderFactory::CreateVideoEncoder " << type; | 158 DCHECK_EQ(type, webrtc::kVideoCodecVP8); |
169 DCHECK(type == webrtc::kVideoCodecVP8); | 159 WebrtcDummyVideoEncoder* encoder = new WebrtcDummyVideoEncoder( |
170 WebrtcDummyVideoEncoder* encoder = new WebrtcDummyVideoEncoder(type); | 160 main_task_runner_, video_channel_state_observer_); |
171 base::AutoLock lock(lock_); | 161 base::AutoLock lock(lock_); |
172 encoder->SetKeyFrameRequestCallback(key_frame_request_); | |
173 encoder->SetTargetBitrateCallback(target_bitrate_cb_); | |
174 VLOG(1) << "Created " << encoder; | |
175 encoders_.push_back(base::WrapUnique(encoder)); | 162 encoders_.push_back(base::WrapUnique(encoder)); |
176 return encoder; | 163 return encoder; |
177 } | 164 } |
178 | 165 |
179 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>& | 166 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>& |
180 WebrtcDummyVideoEncoderFactory::codecs() const { | 167 WebrtcDummyVideoEncoderFactory::codecs() const { |
181 VLOG(2) << "WebrtcDummyVideoEncoderFactory::codecs"; | |
182 return codecs_; | 168 return codecs_; |
183 } | 169 } |
184 | 170 |
185 bool WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource( | 171 bool WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource( |
186 webrtc::VideoCodecType type) const { | 172 webrtc::VideoCodecType type) const { |
187 VLOG(2) << "WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource"; | 173 // Returns true to directly provide encoded frames to webrtc. |
188 return true; | 174 return true; |
189 } | 175 } |
190 | 176 |
191 void WebrtcDummyVideoEncoderFactory::DestroyVideoEncoder( | 177 void WebrtcDummyVideoEncoderFactory::DestroyVideoEncoder( |
192 webrtc::VideoEncoder* encoder) { | 178 webrtc::VideoEncoder* encoder) { |
193 VLOG(2) << "WebrtcDummyVideoEncoderFactory::DestroyVideoEncoder"; | 179 base::AutoLock lock(lock_); |
194 if (encoder == nullptr) { | 180 if (encoder == nullptr) { |
195 LOG(ERROR) << "Attempting to destroy null encoder"; | 181 LOG(ERROR) << "Attempting to destroy null encoder"; |
196 return; | 182 return; |
197 } | 183 } |
198 for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) { | 184 for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) { |
199 if ((*pos).get() == encoder) { | 185 if ((*pos).get() == encoder) { |
200 encoders_.erase(pos); | 186 encoders_.erase(pos); |
201 return; | 187 return; |
202 } | 188 } |
203 } | 189 } |
204 DCHECK(false) << "Asked to remove encoder not owned by factory"; | 190 NOTREACHED() << "Asked to remove encoder not owned by factory."; |
205 } | 191 } |
206 | 192 |
207 webrtc::EncodedImageCallback::Result | 193 webrtc::EncodedImageCallback::Result |
208 WebrtcDummyVideoEncoderFactory::SendEncodedFrame( | 194 WebrtcDummyVideoEncoderFactory::SendEncodedFrame( |
209 const WebrtcVideoEncoder::EncodedFrame& frame, | 195 const WebrtcVideoEncoder::EncodedFrame& frame, |
210 base::TimeTicks capture_time) { | 196 base::TimeTicks capture_time) { |
| 197 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| 198 base::AutoLock lock(lock_); |
211 if (encoders_.size() != 1) { | 199 if (encoders_.size() != 1) { |
212 LOG(ERROR) << "Unexpected number of encoders " << encoders_.size(); | 200 LOG(ERROR) << "Unexpected number of encoders " << encoders_.size(); |
213 return webrtc::EncodedImageCallback::Result( | 201 return webrtc::EncodedImageCallback::Result( |
214 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); | 202 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
215 } | 203 } |
216 return encoders_.front()->SendEncodedFrame(frame, capture_time); | 204 return encoders_.front()->SendEncodedFrame(frame, capture_time); |
217 } | 205 } |
218 | 206 |
219 void WebrtcDummyVideoEncoderFactory::SetKeyFrameRequestCallback( | 207 void WebrtcDummyVideoEncoderFactory::SetVideoChannelStateObserver( |
220 const base::Closure& key_frame_request) { | 208 base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer) { |
| 209 DCHECK(main_task_runner_->BelongsToCurrentThread()); |
| 210 DCHECK(encoders_.empty()); |
221 base::AutoLock lock(lock_); | 211 base::AutoLock lock(lock_); |
222 key_frame_request_ = key_frame_request; | 212 video_channel_state_observer_ = video_channel_state_observer; |
223 if (encoders_.size() == 1) { | |
224 encoders_.front()->SetKeyFrameRequestCallback(key_frame_request); | |
225 } else { | |
226 LOG(ERROR) << "Dropping key frame request callback with unexpected" | |
227 " number of encoders: " | |
228 << encoders_.size(); | |
229 } | |
230 } | |
231 | |
232 void WebrtcDummyVideoEncoderFactory::SetTargetBitrateCallback( | |
233 const TargetBitrateCallback& target_bitrate_cb) { | |
234 base::AutoLock lock(lock_); | |
235 target_bitrate_cb_ = target_bitrate_cb; | |
236 if (encoders_.size() == 1) { | |
237 encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb); | |
238 } else { | |
239 LOG(ERROR) << "Dropping target bitrate request callback with unexpected" | |
240 " number of encoders: " | |
241 << encoders_.size(); | |
242 } | |
243 } | 213 } |
244 | 214 |
245 } // namespace protocol | 215 } // namespace protocol |
246 } // namespace remoting | 216 } // namespace remoting |
OLD | NEW |