Interface with webrtc through encoded frames

remoting/codec/webrtc_video_encoder.cc

Index: remoting/codec/webrtc_video_encoder.cc
diff --git a/remoting/codec/webrtc_video_encoder.cc b/remoting/codec/webrtc_video_encoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f8892b8949ff0eba2ecea97698192d72b6bbebb7
--- /dev/null
+++ b/remoting/codec/webrtc_video_encoder.cc
@@ -0,0 +1,219 @@
+// 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/codec/webrtc_video_encoder.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/logging.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;
+      }
+    }
+  }
+  target_bitrate_ = codec_settings->startBitrate;
+  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) {
+  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;
+  target_bitrate_ = bitrate;
+  // framerate is not expected to be valid given we never report captured
+  // frames
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int WebRtcVideoEncoder::SendEncodedFrame(int64_t capture_timestamp_ms,
+                                         uint8_t* buffer,
+                                         size_t buffer_size,
+                                         int width,
+                                         int height,
+                                         bool key_frame) {
+  base::AutoLock Lock(lock_);

[Sergey Ulanov, 2016/03/31 22:06:18]

lock with lower-case l

[Irfan, 2016/04/05 21:23:27]

Done.

+  if (state_ == kUninitialized) {
+    LOG(ERROR) << "encoder interface uninitialized";
+    return -1;
+  }
+
+  webrtc::EncodedImage encodedImage(buffer, buffer_size, buffer_size);

[Sergey Ulanov, 2016/03/31 22:06:18]

encoded_image

[Irfan, 2016/04/05 21:23:27]

Done.

+  encodedImage._encodedWidth = width;
+  encodedImage._encodedHeight = height;
+  encodedImage._completeFrame = true;
+  encodedImage._frameType =
+      key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta;
+  encodedImage.capture_time_ms_ = capture_timestamp_ms;
+  encodedImage._timeStamp = static_cast<uint32_t>(capture_timestamp_ms * 90);
+
+  webrtc::CodecSpecificInfo codecSpecificInfo;

[Sergey Ulanov, 2016/03/31 22:06:18]

codec_specific_info

[Irfan, 2016/04/05 21:23:27]

Done.

+  memset(&codecSpecificInfo, 0, sizeof(codecSpecificInfo));
+  codecSpecificInfo.codecType = webrtc::kVideoCodecVP8;
+
+  webrtc::RTPFragmentationHeader header;
+  memset(&header, 0, sizeof(header));
+
+  codecSpecificInfo.codecSpecific.VP8.simulcastIdx = 0;
+  codecSpecificInfo.codecSpecific.VP8.temporalIdx = webrtc::kNoTemporalIdx;
+  codecSpecificInfo.codecSpecific.VP8.tl0PicIdx = webrtc::kNoTl0PicIdx;
+  codecSpecificInfo.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;
+
+  int result =
+      encoded_callback_->Encoded(encodedImage, &codecSpecificInfo, &header);
+  if (result < 0) {
+    LOG(ERROR) << "Encoded callback failed: " << result;
+  } else if (result > 0) {
+    VLOG(1) << "Drop request from webrtc";
+  }
+  return result;
+}
+
+void WebRtcVideoEncoder::SetKeyFrameRequestCallback(
+    const base::Closure& key_frame_request) {
+  key_frame_request_ = key_frame_request;
+}
+
+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() {}

[Sergey Ulanov, 2016/03/31 22:06:18]

DCHECK(encoders_.empty())

[Irfan, 2016/04/05 21:23:27]

Done.

+
+webrtc::VideoEncoder* WebRtcVideoEncoderFactory::CreateVideoEncoder(
+    webrtc::VideoCodecType type) {
+  VLOG(2) << "WebRtcVideoEncoderFactory::CreateVideoEncoder " << type;
+  DCHECK(type == webrtc::kVideoCodecVP8);
+  WebRtcVideoEncoder* encoder = new WebRtcVideoEncoder(type);
+  encoder->SetKeyFrameRequestCallback(key_frame_request_);
+  encoders_.push_back(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;
+  }
+  std::vector<WebRtcVideoEncoder*>::iterator position =

[Sergey Ulanov, 2016/03/31 22:06:18]

auto position =

[Irfan, 2016/04/05 21:23:27]

Done.

+      std::find(encoders_.begin(), encoders_.end(), encoder);
+  if (position != encoders_.end()) {
+    encoders_.erase(position);
+    delete encoder;

[Sergey Ulanov, 2016/03/31 22:06:18]

maybe make change type of encoders_ to std::vector<scoped_ptr<RtcVideoEncoder>>
to make it clear that we own them and then you wouldn't need this delete
statement.

[Irfan, 2016/04/05 21:23:27]

Done.

+  } else {
+    LOG(ERROR) << "Asked to remove encoder not owned by factory";

[Sergey Ulanov, 2016/03/31 22:06:18]

replace this with DCHECK().

[Irfan, 2016/04/05 21:23:27]

Done.

+  }
+}
+
+int WebRtcVideoEncoderFactory::SendEncodedFrame(int64_t capture_timestamp_ms,
+                                                uint8_t* buffer,
+                                                size_t buffer_size,
+                                                int width,
+                                                int height,
+                                                bool key_frame) {
+  if (encoders_.size() != 1) {
+    LOG(ERROR) << "Unexpected number of encoders " << encoders_.size();
+    return -1;
+  }
+  return encoders_.front()->SendEncodedFrame(
+      capture_timestamp_ms, buffer, buffer_size, width, height, key_frame);
+}
+
+void WebRtcVideoEncoderFactory::SetKeyFrameRequestCallback(
+    const base::Closure& key_frame_request) {
+  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();
+  }
+}
+
+}  // namespace remoting