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