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_video_encoder_factory.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/callback.h" | 10 #include "base/callback.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/memory/ptr_util.h" | 12 #include "base/memory/ptr_util.h" |
13 #include "base/synchronization/lock.h" | 13 #include "base/synchronization/lock.h" |
14 | 14 |
15 namespace remoting { | 15 namespace remoting { |
| 16 namespace protocol { |
16 | 17 |
17 WebrtcVideoEncoder::WebrtcVideoEncoder(webrtc::VideoCodecType codec) | 18 WebrtcDummyVideoEncoder::WebrtcDummyVideoEncoder(webrtc::VideoCodecType codec) |
18 : state_(kUninitialized), video_codec_type_(codec) { | 19 : state_(kUninitialized), video_codec_type_(codec) { |
19 VLOG(1) << "video codecType " << video_codec_type_; | 20 VLOG(1) << "video codecType " << video_codec_type_; |
20 } | 21 } |
21 | 22 |
22 WebrtcVideoEncoder::~WebrtcVideoEncoder() {} | 23 WebrtcDummyVideoEncoder::~WebrtcDummyVideoEncoder() {} |
23 | 24 |
24 int32_t WebrtcVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings, | 25 int32_t WebrtcDummyVideoEncoder::InitEncode( |
25 int32_t number_of_cores, | 26 const webrtc::VideoCodec* codec_settings, |
26 size_t max_payload_size) { | 27 int32_t number_of_cores, |
| 28 size_t max_payload_size) { |
27 base::AutoLock lock(lock_); | 29 base::AutoLock lock(lock_); |
28 DCHECK(codec_settings); | 30 DCHECK(codec_settings); |
29 VLOG(1) << "video codecType " << codec_settings->codecType << " width " | 31 VLOG(1) << "video codecType " << codec_settings->codecType << " width " |
30 << codec_settings->width << " height " << codec_settings->height | 32 << codec_settings->width << " height " << codec_settings->height |
31 << " startBitrate " << codec_settings->startBitrate << " maxBitrate " | 33 << " startBitrate " << codec_settings->startBitrate << " maxBitrate " |
32 << codec_settings->maxBitrate << " minBitrate " | 34 << codec_settings->maxBitrate << " minBitrate " |
33 << codec_settings->minBitrate << " targetBitrate " | 35 << codec_settings->minBitrate << " targetBitrate " |
34 << codec_settings->targetBitrate << " maxFramerate " | 36 << codec_settings->targetBitrate << " maxFramerate " |
35 << codec_settings->maxFramerate; | 37 << codec_settings->maxFramerate; |
36 | 38 |
37 int streamCount = codec_settings->numberOfSimulcastStreams; | 39 int streamCount = codec_settings->numberOfSimulcastStreams; |
38 // Validate request is to support a single stream. | 40 // Validate request is to support a single stream. |
39 if (streamCount > 1) { | 41 if (streamCount > 1) { |
40 for (int i = 0; i < streamCount; ++i) { | 42 for (int i = 0; i < streamCount; ++i) { |
41 if (codec_settings->simulcastStream[i].maxBitrate != 0) { | 43 if (codec_settings->simulcastStream[i].maxBitrate != 0) { |
42 LOG(ERROR) << "Simulcast unsupported"; | 44 LOG(ERROR) << "Simulcast unsupported"; |
43 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; | 45 return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
44 } | 46 } |
45 } | 47 } |
46 } | 48 } |
47 state_ = kInitialized; | 49 state_ = kInitialized; |
48 return WEBRTC_VIDEO_CODEC_OK; | 50 return WEBRTC_VIDEO_CODEC_OK; |
49 } | 51 } |
50 | 52 |
51 int32_t WebrtcVideoEncoder::RegisterEncodeCompleteCallback( | 53 int32_t WebrtcDummyVideoEncoder::RegisterEncodeCompleteCallback( |
52 webrtc::EncodedImageCallback* callback) { | 54 webrtc::EncodedImageCallback* callback) { |
53 base::AutoLock lock(lock_); | 55 base::AutoLock lock(lock_); |
54 DCHECK(callback); | 56 DCHECK(callback); |
55 encoded_callback_ = callback; | 57 encoded_callback_ = callback; |
56 return WEBRTC_VIDEO_CODEC_OK; | 58 return WEBRTC_VIDEO_CODEC_OK; |
57 } | 59 } |
58 | 60 |
59 int32_t WebrtcVideoEncoder::Release() { | 61 int32_t WebrtcDummyVideoEncoder::Release() { |
60 base::AutoLock lock(lock_); | 62 base::AutoLock lock(lock_); |
61 encoded_callback_ = nullptr; | 63 encoded_callback_ = nullptr; |
62 return WEBRTC_VIDEO_CODEC_OK; | 64 return WEBRTC_VIDEO_CODEC_OK; |
63 } | 65 } |
64 | 66 |
65 int32_t WebrtcVideoEncoder::Encode( | 67 int32_t WebrtcDummyVideoEncoder::Encode( |
66 const webrtc::VideoFrame& frame, | 68 const webrtc::VideoFrame& frame, |
67 const webrtc::CodecSpecificInfo* codec_specific_info, | 69 const webrtc::CodecSpecificInfo* codec_specific_info, |
68 const std::vector<webrtc::FrameType>* frame_types) { | 70 const std::vector<webrtc::FrameType>* frame_types) { |
69 base::AutoLock lock(lock_); | 71 base::AutoLock lock(lock_); |
70 if (!key_frame_request_.is_null()) | 72 if (!key_frame_request_.is_null()) |
71 key_frame_request_.Run(); | 73 key_frame_request_.Run(); |
72 return WEBRTC_VIDEO_CODEC_OK; | 74 return WEBRTC_VIDEO_CODEC_OK; |
73 } | 75 } |
74 | 76 |
75 int32_t WebrtcVideoEncoder::SetChannelParameters(uint32_t packet_loss, | 77 int32_t WebrtcDummyVideoEncoder::SetChannelParameters(uint32_t packet_loss, |
76 int64_t rtt) { | 78 int64_t rtt) { |
77 VLOG(1) << "WebrtcVideoEncoder::SetChannelParameters " | 79 VLOG(1) << "WebrtcDummyVideoEncoder::SetChannelParameters " |
78 << "loss:RTT " << packet_loss << ":" << rtt; | 80 << "loss:RTT " << packet_loss << ":" << rtt; |
79 // Unused right now. | 81 // Unused right now. |
80 return WEBRTC_VIDEO_CODEC_OK; | 82 return WEBRTC_VIDEO_CODEC_OK; |
81 } | 83 } |
82 | 84 |
83 int32_t WebrtcVideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) { | 85 int32_t WebrtcDummyVideoEncoder::SetRates(uint32_t bitrate, |
84 VLOG(1) << "WebrtcVideoEncoder::SetRates bitrate:framerate " << bitrate << ":" | 86 uint32_t framerate) { |
85 << framerate; | 87 VLOG(1) << "WebrtcDummyVideoEncoder::SetRates bitrate:framerate " << bitrate |
| 88 << ":" << framerate; |
86 if (!target_bitrate_cb_.is_null()) | 89 if (!target_bitrate_cb_.is_null()) |
87 target_bitrate_cb_.Run(bitrate); | 90 target_bitrate_cb_.Run(bitrate); |
88 // 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 |
89 // frames | 92 // frames |
90 return WEBRTC_VIDEO_CODEC_OK; | 93 return WEBRTC_VIDEO_CODEC_OK; |
91 } | 94 } |
92 | 95 |
93 webrtc::EncodedImageCallback::Result WebrtcVideoEncoder::SendEncodedFrame( | 96 webrtc::EncodedImageCallback::Result WebrtcDummyVideoEncoder::SendEncodedFrame( |
94 std::unique_ptr<VideoPacket> frame, | 97 std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame, |
95 base::TimeTicks capture_time) { | 98 base::TimeTicks capture_time) { |
96 uint8_t* buffer = | 99 uint8_t* buffer = |
97 reinterpret_cast<uint8_t*>(const_cast<char*>(frame->data().data())); | 100 reinterpret_cast<uint8_t*>(const_cast<char*>(frame->data.data())); |
98 size_t buffer_size = frame->data().size(); | 101 size_t buffer_size = frame->data.size(); |
99 base::AutoLock lock(lock_); | 102 base::AutoLock lock(lock_); |
100 if (state_ == kUninitialized) { | 103 if (state_ == kUninitialized) { |
101 LOG(ERROR) << "encoder interface uninitialized"; | 104 LOG(ERROR) << "encoder interface uninitialized"; |
102 return webrtc::EncodedImageCallback::Result( | 105 return webrtc::EncodedImageCallback::Result( |
103 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); | 106 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
104 } | 107 } |
105 | 108 |
106 webrtc::EncodedImage encoded_image(buffer, buffer_size, buffer_size); | 109 webrtc::EncodedImage encoded_image(buffer, buffer_size, buffer_size); |
107 encoded_image._encodedWidth = frame->format().screen_width(); | 110 encoded_image._encodedWidth = frame->size.width(); |
108 encoded_image._encodedHeight = frame->format().screen_height(); | 111 encoded_image._encodedHeight = frame->size.height(); |
109 encoded_image._completeFrame = true; | 112 encoded_image._completeFrame = true; |
110 encoded_image._frameType = | 113 encoded_image._frameType = |
111 frame->key_frame() ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta; | 114 frame->key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta; |
112 int64_t capture_time_ms = (capture_time - base::TimeTicks()).InMilliseconds(); | 115 int64_t capture_time_ms = (capture_time - base::TimeTicks()).InMilliseconds(); |
113 encoded_image.capture_time_ms_ = capture_time_ms; | 116 encoded_image.capture_time_ms_ = capture_time_ms; |
114 encoded_image._timeStamp = static_cast<uint32_t>(capture_time_ms * 90); | 117 encoded_image._timeStamp = static_cast<uint32_t>(capture_time_ms * 90); |
115 encoded_image.playout_delay_.min_ms = 0; | 118 encoded_image.playout_delay_.min_ms = 0; |
116 encoded_image.playout_delay_.max_ms = 0; | 119 encoded_image.playout_delay_.max_ms = 0; |
117 | 120 |
118 webrtc::CodecSpecificInfo codec_specific_info; | 121 webrtc::CodecSpecificInfo codec_specific_info; |
119 memset(&codec_specific_info, 0, sizeof(codec_specific_info)); | 122 memset(&codec_specific_info, 0, sizeof(codec_specific_info)); |
120 codec_specific_info.codecType = webrtc::kVideoCodecVP8; | 123 codec_specific_info.codecType = webrtc::kVideoCodecVP8; |
121 | 124 |
122 webrtc::RTPFragmentationHeader header; | 125 webrtc::RTPFragmentationHeader header; |
123 memset(&header, 0, sizeof(header)); | 126 memset(&header, 0, sizeof(header)); |
124 | 127 |
125 codec_specific_info.codecSpecific.VP8.simulcastIdx = 0; | 128 codec_specific_info.codecSpecific.VP8.simulcastIdx = 0; |
126 codec_specific_info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx; | 129 codec_specific_info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx; |
127 codec_specific_info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx; | 130 codec_specific_info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx; |
128 codec_specific_info.codecSpecific.VP8.pictureId = webrtc::kNoPictureId; | 131 codec_specific_info.codecSpecific.VP8.pictureId = webrtc::kNoPictureId; |
129 | 132 |
130 header.VerifyAndAllocateFragmentationHeader(1); | 133 header.VerifyAndAllocateFragmentationHeader(1); |
131 header.fragmentationOffset[0] = 0; | 134 header.fragmentationOffset[0] = 0; |
132 header.fragmentationLength[0] = buffer_size; | 135 header.fragmentationLength[0] = buffer_size; |
133 header.fragmentationPlType[0] = 0; | 136 header.fragmentationPlType[0] = 0; |
134 header.fragmentationTimeDiff[0] = 0; | 137 header.fragmentationTimeDiff[0] = 0; |
135 | 138 |
136 return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info, | 139 return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info, |
137 &header); | 140 &header); |
138 } | 141 } |
139 | 142 |
140 void WebrtcVideoEncoder::SetKeyFrameRequestCallback( | 143 void WebrtcDummyVideoEncoder::SetKeyFrameRequestCallback( |
141 const base::Closure& key_frame_request) { | 144 const base::Closure& key_frame_request) { |
142 base::AutoLock lock(lock_); | 145 base::AutoLock lock(lock_); |
143 key_frame_request_ = key_frame_request; | 146 key_frame_request_ = key_frame_request; |
144 } | 147 } |
145 | 148 |
146 void WebrtcVideoEncoder::SetTargetBitrateCallback( | 149 void WebrtcDummyVideoEncoder::SetTargetBitrateCallback( |
147 const TargetBitrateCallback& target_bitrate_cb) { | 150 const TargetBitrateCallback& target_bitrate_cb) { |
148 base::AutoLock lock(lock_); | 151 base::AutoLock lock(lock_); |
149 target_bitrate_cb_ = target_bitrate_cb; | 152 target_bitrate_cb_ = target_bitrate_cb; |
150 } | 153 } |
151 | 154 |
152 WebrtcVideoEncoderFactory::WebrtcVideoEncoderFactory() { | 155 WebrtcDummyVideoEncoderFactory::WebrtcDummyVideoEncoderFactory() { |
153 // TODO(isheriff): These do not really affect anything internally | 156 // TODO(isheriff): These do not really affect anything internally |
154 // in webrtc. | 157 // in webrtc. |
155 codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec( | 158 codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec( |
156 webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30)); | 159 webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30)); |
157 } | 160 } |
158 | 161 |
159 WebrtcVideoEncoderFactory::~WebrtcVideoEncoderFactory() { | 162 WebrtcDummyVideoEncoderFactory::~WebrtcDummyVideoEncoderFactory() { |
160 DCHECK(encoders_.empty()); | 163 DCHECK(encoders_.empty()); |
161 } | 164 } |
162 | 165 |
163 webrtc::VideoEncoder* WebrtcVideoEncoderFactory::CreateVideoEncoder( | 166 webrtc::VideoEncoder* WebrtcDummyVideoEncoderFactory::CreateVideoEncoder( |
164 webrtc::VideoCodecType type) { | 167 webrtc::VideoCodecType type) { |
165 VLOG(2) << "WebrtcVideoEncoderFactory::CreateVideoEncoder " << type; | 168 VLOG(2) << "WebrtcDummyVideoEncoderFactory::CreateVideoEncoder " << type; |
166 DCHECK(type == webrtc::kVideoCodecVP8); | 169 DCHECK(type == webrtc::kVideoCodecVP8); |
167 WebrtcVideoEncoder* encoder = new WebrtcVideoEncoder(type); | 170 WebrtcDummyVideoEncoder* encoder = new WebrtcDummyVideoEncoder(type); |
168 base::AutoLock lock(lock_); | 171 base::AutoLock lock(lock_); |
169 encoder->SetKeyFrameRequestCallback(key_frame_request_); | 172 encoder->SetKeyFrameRequestCallback(key_frame_request_); |
170 encoder->SetTargetBitrateCallback(target_bitrate_cb_); | 173 encoder->SetTargetBitrateCallback(target_bitrate_cb_); |
171 VLOG(1) << "Created " << encoder; | 174 VLOG(1) << "Created " << encoder; |
172 encoders_.push_back(base::WrapUnique(encoder)); | 175 encoders_.push_back(base::WrapUnique(encoder)); |
173 return encoder; | 176 return encoder; |
174 } | 177 } |
175 | 178 |
176 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>& | 179 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>& |
177 WebrtcVideoEncoderFactory::codecs() const { | 180 WebrtcDummyVideoEncoderFactory::codecs() const { |
178 VLOG(2) << "WebrtcVideoEncoderFactory::codecs"; | 181 VLOG(2) << "WebrtcDummyVideoEncoderFactory::codecs"; |
179 return codecs_; | 182 return codecs_; |
180 } | 183 } |
181 | 184 |
182 bool WebrtcVideoEncoderFactory::EncoderTypeHasInternalSource( | 185 bool WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource( |
183 webrtc::VideoCodecType type) const { | 186 webrtc::VideoCodecType type) const { |
184 VLOG(2) << "WebrtcVideoEncoderFactory::EncoderTypeHasInternalSource"; | 187 VLOG(2) << "WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource"; |
185 return true; | 188 return true; |
186 } | 189 } |
187 | 190 |
188 void WebrtcVideoEncoderFactory::DestroyVideoEncoder( | 191 void WebrtcDummyVideoEncoderFactory::DestroyVideoEncoder( |
189 webrtc::VideoEncoder* encoder) { | 192 webrtc::VideoEncoder* encoder) { |
190 VLOG(2) << "WebrtcVideoEncoderFactory::DestroyVideoEncoder"; | 193 VLOG(2) << "WebrtcDummyVideoEncoderFactory::DestroyVideoEncoder"; |
191 if (encoder == nullptr) { | 194 if (encoder == nullptr) { |
192 LOG(ERROR) << "Attempting to destroy null encoder"; | 195 LOG(ERROR) << "Attempting to destroy null encoder"; |
193 return; | 196 return; |
194 } | 197 } |
195 for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) { | 198 for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) { |
196 if ((*pos).get() == encoder) { | 199 if ((*pos).get() == encoder) { |
197 encoders_.erase(pos); | 200 encoders_.erase(pos); |
198 return; | 201 return; |
199 } | 202 } |
200 } | 203 } |
201 DCHECK(false) << "Asked to remove encoder not owned by factory"; | 204 DCHECK(false) << "Asked to remove encoder not owned by factory"; |
202 } | 205 } |
203 | 206 |
204 webrtc::EncodedImageCallback::Result | 207 webrtc::EncodedImageCallback::Result |
205 WebrtcVideoEncoderFactory::SendEncodedFrame(std::unique_ptr<VideoPacket> frame, | 208 WebrtcDummyVideoEncoderFactory::SendEncodedFrame( |
206 base::TimeTicks capture_time) { | 209 std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame, |
| 210 base::TimeTicks capture_time) { |
207 if (encoders_.size() != 1) { | 211 if (encoders_.size() != 1) { |
208 LOG(ERROR) << "Unexpected number of encoders " << encoders_.size(); | 212 LOG(ERROR) << "Unexpected number of encoders " << encoders_.size(); |
209 return webrtc::EncodedImageCallback::Result( | 213 return webrtc::EncodedImageCallback::Result( |
210 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); | 214 webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
211 } | 215 } |
212 return encoders_.front()->SendEncodedFrame(std::move(frame), capture_time); | 216 return encoders_.front()->SendEncodedFrame(std::move(frame), capture_time); |
213 } | 217 } |
214 | 218 |
215 void WebrtcVideoEncoderFactory::SetKeyFrameRequestCallback( | 219 void WebrtcDummyVideoEncoderFactory::SetKeyFrameRequestCallback( |
216 const base::Closure& key_frame_request) { | 220 const base::Closure& key_frame_request) { |
217 base::AutoLock lock(lock_); | 221 base::AutoLock lock(lock_); |
218 key_frame_request_ = key_frame_request; | 222 key_frame_request_ = key_frame_request; |
219 if (encoders_.size() == 1) { | 223 if (encoders_.size() == 1) { |
220 encoders_.front()->SetKeyFrameRequestCallback(key_frame_request); | 224 encoders_.front()->SetKeyFrameRequestCallback(key_frame_request); |
221 } else { | 225 } else { |
222 LOG(ERROR) << "Dropping key frame request callback with unexpected" | 226 LOG(ERROR) << "Dropping key frame request callback with unexpected" |
223 " number of encoders: " | 227 " number of encoders: " |
224 << encoders_.size(); | 228 << encoders_.size(); |
225 } | 229 } |
226 } | 230 } |
227 | 231 |
228 void WebrtcVideoEncoderFactory::SetTargetBitrateCallback( | 232 void WebrtcDummyVideoEncoderFactory::SetTargetBitrateCallback( |
229 const TargetBitrateCallback& target_bitrate_cb) { | 233 const TargetBitrateCallback& target_bitrate_cb) { |
230 base::AutoLock lock(lock_); | 234 base::AutoLock lock(lock_); |
231 target_bitrate_cb_ = target_bitrate_cb; | 235 target_bitrate_cb_ = target_bitrate_cb; |
232 if (encoders_.size() == 1) { | 236 if (encoders_.size() == 1) { |
233 encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb); | 237 encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb); |
234 } else { | 238 } else { |
235 LOG(ERROR) << "Dropping target bitrate request callback with unexpected" | 239 LOG(ERROR) << "Dropping target bitrate request callback with unexpected" |
236 " number of encoders: " | 240 " number of encoders: " |
237 << encoders_.size(); | 241 << encoders_.size(); |
238 } | 242 } |
239 } | 243 } |
240 | 244 |
| 245 } // namespace protocol |
241 } // namespace remoting | 246 } // namespace remoting |
OLD | NEW |