Index: remoting/protocol/webrtc_video_encoder_factory.cc |
diff --git a/remoting/protocol/webrtc_video_encoder_factory.cc b/remoting/protocol/webrtc_video_encoder_factory.cc |
deleted file mode 100644 |
index b2d6fa17d49a3d248cc06a530c82907391158abe..0000000000000000000000000000000000000000 |
--- a/remoting/protocol/webrtc_video_encoder_factory.cc |
+++ /dev/null |
@@ -1,241 +0,0 @@ |
-// Copyright 2016 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/protocol/webrtc_video_encoder_factory.h" |
- |
-#include <algorithm> |
-#include <vector> |
- |
-#include "base/callback.h" |
-#include "base/logging.h" |
-#include "base/memory/ptr_util.h" |
-#include "base/synchronization/lock.h" |
- |
-namespace remoting { |
- |
-WebrtcVideoEncoder::WebrtcVideoEncoder(webrtc::VideoCodecType codec) |
- : state_(kUninitialized), video_codec_type_(codec) { |
- VLOG(1) << "video codecType " << video_codec_type_; |
-} |
- |
-WebrtcVideoEncoder::~WebrtcVideoEncoder() {} |
- |
-int32_t WebrtcVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings, |
- int32_t number_of_cores, |
- size_t max_payload_size) { |
- base::AutoLock lock(lock_); |
- DCHECK(codec_settings); |
- VLOG(1) << "video codecType " << codec_settings->codecType << " width " |
- << codec_settings->width << " height " << codec_settings->height |
- << " startBitrate " << codec_settings->startBitrate << " maxBitrate " |
- << codec_settings->maxBitrate << " minBitrate " |
- << codec_settings->minBitrate << " targetBitrate " |
- << codec_settings->targetBitrate << " maxFramerate " |
- << codec_settings->maxFramerate; |
- |
- int streamCount = codec_settings->numberOfSimulcastStreams; |
- // Validate request is to support a single stream. |
- if (streamCount > 1) { |
- for (int i = 0; i < streamCount; ++i) { |
- if (codec_settings->simulcastStream[i].maxBitrate != 0) { |
- LOG(ERROR) << "Simulcast unsupported"; |
- return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; |
- } |
- } |
- } |
- state_ = kInitialized; |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-int32_t WebrtcVideoEncoder::RegisterEncodeCompleteCallback( |
- webrtc::EncodedImageCallback* callback) { |
- base::AutoLock lock(lock_); |
- DCHECK(callback); |
- encoded_callback_ = callback; |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-int32_t WebrtcVideoEncoder::Release() { |
- base::AutoLock lock(lock_); |
- encoded_callback_ = nullptr; |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-int32_t WebrtcVideoEncoder::Encode( |
- const webrtc::VideoFrame& frame, |
- const webrtc::CodecSpecificInfo* codec_specific_info, |
- const std::vector<webrtc::FrameType>* frame_types) { |
- base::AutoLock lock(lock_); |
- if (!key_frame_request_.is_null()) |
- key_frame_request_.Run(); |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-int32_t WebrtcVideoEncoder::SetChannelParameters(uint32_t packet_loss, |
- int64_t rtt) { |
- VLOG(1) << "WebrtcVideoEncoder::SetChannelParameters " |
- << "loss:RTT " << packet_loss << ":" << rtt; |
- // Unused right now. |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-int32_t WebrtcVideoEncoder::SetRates(uint32_t bitrate, uint32_t framerate) { |
- VLOG(1) << "WebrtcVideoEncoder::SetRates bitrate:framerate " << bitrate << ":" |
- << framerate; |
- if (!target_bitrate_cb_.is_null()) |
- target_bitrate_cb_.Run(bitrate); |
- // framerate is not expected to be valid given we never report captured |
- // frames |
- return WEBRTC_VIDEO_CODEC_OK; |
-} |
- |
-webrtc::EncodedImageCallback::Result WebrtcVideoEncoder::SendEncodedFrame( |
- std::unique_ptr<VideoPacket> frame, |
- base::TimeTicks capture_time) { |
- uint8_t* buffer = |
- reinterpret_cast<uint8_t*>(const_cast<char*>(frame->data().data())); |
- size_t buffer_size = frame->data().size(); |
- base::AutoLock lock(lock_); |
- if (state_ == kUninitialized) { |
- LOG(ERROR) << "encoder interface uninitialized"; |
- return webrtc::EncodedImageCallback::Result( |
- webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
- } |
- |
- webrtc::EncodedImage encoded_image(buffer, buffer_size, buffer_size); |
- encoded_image._encodedWidth = frame->format().screen_width(); |
- encoded_image._encodedHeight = frame->format().screen_height(); |
- encoded_image._completeFrame = true; |
- encoded_image._frameType = |
- frame->key_frame() ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta; |
- int64_t capture_time_ms = (capture_time - base::TimeTicks()).InMilliseconds(); |
- encoded_image.capture_time_ms_ = capture_time_ms; |
- encoded_image._timeStamp = static_cast<uint32_t>(capture_time_ms * 90); |
- encoded_image.playout_delay_.min_ms = 0; |
- encoded_image.playout_delay_.max_ms = 0; |
- |
- webrtc::CodecSpecificInfo codec_specific_info; |
- memset(&codec_specific_info, 0, sizeof(codec_specific_info)); |
- codec_specific_info.codecType = webrtc::kVideoCodecVP8; |
- |
- webrtc::RTPFragmentationHeader header; |
- memset(&header, 0, sizeof(header)); |
- |
- codec_specific_info.codecSpecific.VP8.simulcastIdx = 0; |
- codec_specific_info.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx; |
- codec_specific_info.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx; |
- codec_specific_info.codecSpecific.VP8.pictureId = webrtc::kNoPictureId; |
- |
- header.VerifyAndAllocateFragmentationHeader(1); |
- header.fragmentationOffset[0] = 0; |
- header.fragmentationLength[0] = buffer_size; |
- header.fragmentationPlType[0] = 0; |
- header.fragmentationTimeDiff[0] = 0; |
- |
- return encoded_callback_->OnEncodedImage(encoded_image, &codec_specific_info, |
- &header); |
-} |
- |
-void WebrtcVideoEncoder::SetKeyFrameRequestCallback( |
- const base::Closure& key_frame_request) { |
- base::AutoLock lock(lock_); |
- key_frame_request_ = key_frame_request; |
-} |
- |
-void WebrtcVideoEncoder::SetTargetBitrateCallback( |
- const TargetBitrateCallback& target_bitrate_cb) { |
- base::AutoLock lock(lock_); |
- target_bitrate_cb_ = target_bitrate_cb; |
-} |
- |
-WebrtcVideoEncoderFactory::WebrtcVideoEncoderFactory() { |
- // TODO(isheriff): These do not really affect anything internally |
- // in webrtc. |
- codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec( |
- webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30)); |
-} |
- |
-WebrtcVideoEncoderFactory::~WebrtcVideoEncoderFactory() { |
- DCHECK(encoders_.empty()); |
-} |
- |
-webrtc::VideoEncoder* WebrtcVideoEncoderFactory::CreateVideoEncoder( |
- webrtc::VideoCodecType type) { |
- VLOG(2) << "WebrtcVideoEncoderFactory::CreateVideoEncoder " << type; |
- DCHECK(type == webrtc::kVideoCodecVP8); |
- WebrtcVideoEncoder* encoder = new WebrtcVideoEncoder(type); |
- base::AutoLock lock(lock_); |
- encoder->SetKeyFrameRequestCallback(key_frame_request_); |
- encoder->SetTargetBitrateCallback(target_bitrate_cb_); |
- VLOG(1) << "Created " << encoder; |
- encoders_.push_back(base::WrapUnique(encoder)); |
- return encoder; |
-} |
- |
-const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>& |
-WebrtcVideoEncoderFactory::codecs() const { |
- VLOG(2) << "WebrtcVideoEncoderFactory::codecs"; |
- return codecs_; |
-} |
- |
-bool WebrtcVideoEncoderFactory::EncoderTypeHasInternalSource( |
- webrtc::VideoCodecType type) const { |
- VLOG(2) << "WebrtcVideoEncoderFactory::EncoderTypeHasInternalSource"; |
- return true; |
-} |
- |
-void WebrtcVideoEncoderFactory::DestroyVideoEncoder( |
- webrtc::VideoEncoder* encoder) { |
- VLOG(2) << "WebrtcVideoEncoderFactory::DestroyVideoEncoder"; |
- if (encoder == nullptr) { |
- LOG(ERROR) << "Attempting to destroy null encoder"; |
- return; |
- } |
- for (auto pos = encoders_.begin(); pos != encoders_.end(); ++pos) { |
- if ((*pos).get() == encoder) { |
- encoders_.erase(pos); |
- return; |
- } |
- } |
- DCHECK(false) << "Asked to remove encoder not owned by factory"; |
-} |
- |
-webrtc::EncodedImageCallback::Result |
-WebrtcVideoEncoderFactory::SendEncodedFrame(std::unique_ptr<VideoPacket> frame, |
- base::TimeTicks capture_time) { |
- if (encoders_.size() != 1) { |
- LOG(ERROR) << "Unexpected number of encoders " << encoders_.size(); |
- return webrtc::EncodedImageCallback::Result( |
- webrtc::EncodedImageCallback::Result::ERROR_SEND_FAILED); |
- } |
- return encoders_.front()->SendEncodedFrame(std::move(frame), capture_time); |
-} |
- |
-void WebrtcVideoEncoderFactory::SetKeyFrameRequestCallback( |
- const base::Closure& key_frame_request) { |
- base::AutoLock lock(lock_); |
- key_frame_request_ = key_frame_request; |
- if (encoders_.size() == 1) { |
- encoders_.front()->SetKeyFrameRequestCallback(key_frame_request); |
- } else { |
- LOG(ERROR) << "Dropping key frame request callback with unexpected" |
- " number of encoders: " |
- << encoders_.size(); |
- } |
-} |
- |
-void WebrtcVideoEncoderFactory::SetTargetBitrateCallback( |
- const TargetBitrateCallback& target_bitrate_cb) { |
- base::AutoLock lock(lock_); |
- target_bitrate_cb_ = target_bitrate_cb; |
- if (encoders_.size() == 1) { |
- encoders_.front()->SetTargetBitrateCallback(target_bitrate_cb); |
- } else { |
- LOG(ERROR) << "Dropping target bitrate request callback with unexpected" |
- " number of encoders: " |
- << encoders_.size(); |
- } |
-} |
- |
-} // namespace remoting |