[Remoting Host] Supporting WebRTC VP9 streaming

remoting/protocol/webrtc_dummy_video_encoder.cc

 // 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_dummy_video_encoder.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "remoting/protocol/video_channel_state_observer.h"
 
 namespace remoting {
 namespace protocol {
 
 WebrtcDummyVideoEncoder::WebrtcDummyVideoEncoder(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-    base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer)
+    base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer,
+    webrtc::VideoCodecType type)
     : main_task_runner_(main_task_runner),
       state_(kUninitialized),
-      video_channel_state_observer_(video_channel_state_observer) {}
+      codec_type_(type),
+      video_channel_state_observer_(video_channel_state_observer) {
+  DCHECK(type == webrtc::kVideoCodecVP8 || type == webrtc::kVideoCodecVP9);
+}
 
 WebrtcDummyVideoEncoder::~WebrtcDummyVideoEncoder() {}
 
 int32_t WebrtcDummyVideoEncoder::InitEncode(
     const webrtc::VideoCodec* codec_settings,
     int32_t number_of_cores,
     size_t max_payload_size) {
   DCHECK(codec_settings);
   base::AutoLock lock(lock_);
   int stream_count = codec_settings->numberOfSimulcastStreams;
@@ skipping 77 matching lines @@
   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;
+  codec_specific_info.codecType = codec_type_;
+
+  if (codec_type_ == webrtc::kVideoCodecVP8) {
+    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;
+  } else if (codec_type_ == webrtc::kVideoCodecVP9) {
+    codec_specific_info.codecSpecific.generic.simulcast_idx = 0;
+    codec_specific_info.codecSpecific.VP9.gof_idx = webrtc::kNoGofIdx;
+    codec_specific_info.codecSpecific.VP9.temporal_idx = webrtc::kNoTemporalIdx;
+    codec_specific_info.codecSpecific.VP9.spatial_idx = webrtc::kNoSpatialIdx;
+    codec_specific_info.codecSpecific.VP9.tl0_pic_idx = webrtc::kNoTl0PicIdx;
+    codec_specific_info.codecSpecific.VP9.picture_id = webrtc::kNoPictureId;
+  } else {
+    LOG(FATAL) << "Unsupported codec: " << codec_type_;

[Sergey Ulanov, 2017/03/31 19:23:11]

NOTREACHED().

[Yuwei, 2017/04/03 22:29:10]

Done.

+  }
 
   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);
 }
 
 WebrtcDummyVideoEncoderFactory::WebrtcDummyVideoEncoderFactory()
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   // TODO(isheriff): These do not really affect anything internally
   // in webrtc.
   codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec(
-      webrtc::kVideoCodecVP8, "VP8", 1280, 720, 30));
+      webrtc::kVideoCodecVP9, "VP8", 1280, 720, 30));
+  codecs_.push_back(cricket::WebRtcVideoEncoderFactory::VideoCodec(
+      webrtc::kVideoCodecVP9, "VP9", 1280, 720, 30));
 }
 
 WebrtcDummyVideoEncoderFactory::~WebrtcDummyVideoEncoderFactory() {
   DCHECK(encoders_.empty());
 }
 
 webrtc::VideoEncoder* WebrtcDummyVideoEncoderFactory::CreateVideoEncoder(
     webrtc::VideoCodecType type) {
-  DCHECK_EQ(type, webrtc::kVideoCodecVP8);
   WebrtcDummyVideoEncoder* encoder = new WebrtcDummyVideoEncoder(
-      main_task_runner_, video_channel_state_observer_);
+      main_task_runner_, video_channel_state_observer_, type);
   base::AutoLock lock(lock_);
   encoders_.push_back(base::WrapUnique(encoder));
+  if (encoder_created_callback_) {
+    main_task_runner_->PostTask(FROM_HERE,
+                                base::Bind(encoder_created_callback_, type));
+  }
   return encoder;
 }
 
 const std::vector<cricket::WebRtcVideoEncoderFactory::VideoCodec>&
 WebrtcDummyVideoEncoderFactory::codecs() const {
   return codecs_;
 }
 
 bool WebrtcDummyVideoEncoderFactory::EncoderTypeHasInternalSource(
     webrtc::VideoCodecType type) const {
@@ skipping 24 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   base::AutoLock lock(lock_);
   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(frame, capture_time);
 }
 
+void WebrtcDummyVideoEncoderFactory::SetEncoderCreatedCallback(
+    const base::Callback<void(webrtc::VideoCodecType)>& callback) {
+  encoder_created_callback_ = callback;
+}
+
 void WebrtcDummyVideoEncoderFactory::SetVideoChannelStateObserver(
     base::WeakPtr<VideoChannelStateObserver> video_channel_state_observer) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(encoders_.empty());
   base::AutoLock lock(lock_);
   video_channel_state_observer_ = video_channel_state_observer;
 }
 
 }  // namespace protocol
 }  // namespace remoting