[Remoting Host] Supporting WebRTC VP9 streaming

remoting/protocol/webrtc_video_stream.cc

 // Copyright 2015 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_stream.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "remoting/base/constants.h"
 #include "remoting/codec/webrtc_video_encoder_vpx.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/host_video_stats_dispatcher.h"
 #include "remoting/protocol/webrtc_dummy_video_capturer.h"
 #include "remoting/protocol/webrtc_frame_scheduler_simple.h"
@@ skipping 50 matching lines @@
 
   scoped_refptr<webrtc::PeerConnectionFactoryInterface> peer_connection_factory(
       webrtc_transport->peer_connection_factory());
   peer_connection_ = webrtc_transport->peer_connection();
   DCHECK(peer_connection_factory);
   DCHECK(peer_connection_);
 
   encode_task_runner_ = std::move(encode_task_runner);
   capturer_ = std::move(desktop_capturer);
   webrtc_transport_ = webrtc_transport;
-  // TODO(isheriff): make this codec independent
-  encoder_ = WebrtcVideoEncoderVpx::CreateForVP8();
+
+  webrtc_transport_->video_encoder_factory()->SetEncoderCreatedCallback(

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

Maybe call it "EncoderSelectedCallback"? That would help to avoid confusion as
the encoder is actually created by the handler of this calblack.

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

Done.

+      base::Bind(&WebrtcVideoStream::OnEncoderCreated,
+                 weak_factory_.GetWeakPtr()));
+
   capturer_->Start(this);
 
   // Set video stream constraints.
   webrtc::FakeConstraints video_constraints;
   video_constraints.AddMandatory(
       webrtc::MediaConstraintsInterface::kMinFrameRate, 5);
 
   rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> src =
       peer_connection_factory->CreateVideoSource(new WebrtcDummyVideoCapturer(),
                                                  &video_constraints);
@@ skipping 66 matching lines @@
                                : frame->dpi();
 
     if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
       frame_size_ = frame->size();
       frame_dpi_ = dpi;
       if (observer_)
         observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
     }
   }
 
+  if (!encoder_) {
+    LOG(WARNING) << "Encoder has not been created yet.";

[Yuwei, 2017/03/29 01:08:33]

I'm not sure whether this is very safe but IIUC the scheduler will always
capture new frames as long as the last frame has captured and it's the
|encoder_| itself deciding how to do incremental updates.

Let me know if I got anything wrong O_o

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

I think we need to fix this in WebrtcFrameSchedulerSimple. It shouldn't request
a frame until OnKeyFrameRequested() is called for the first time (by
WebrtcDummyVideoEncoder::Encode()). The first key frame request indicates that
the capturer has been created successfully.
WebrtcFrameSchedulerSimple::ScheduleNextFrame() should only schedule a frame if
a key frame request has been received.

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

Done.

+    return;
+  }
+
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebrtcVideoStream::EncodeFrame, encoder_.get(),
                  base::Passed(std::move(frame)), frame_params,
                  base::Passed(std::move(captured_frame_timestamps_))),
       base::Bind(&WebrtcVideoStream::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcVideoStream::OnChannelInitialized(
@@ skipping 72 matching lines @@
     stats.encode_pending_delay = frame.timestamps->encode_started_time -
                                  frame.timestamps->capture_ended_time;
 
     stats.encode_delay = frame.timestamps->encode_ended_time -
                          frame.timestamps->encode_started_time;
 
     video_stats_dispatcher_.OnVideoFrameStats(result.frame_id, stats);
   }
 }
 
+void WebrtcVideoStream::OnEncoderCreated(webrtc::VideoCodecType codec_type) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (codec_type == webrtc::kVideoCodecVP8) {
+    encoder_ = WebrtcVideoEncoderVpx::CreateForVP8();
+  } else if (codec_type == webrtc::kVideoCodecVP9) {
+    encoder_ = WebrtcVideoEncoderVpx::CreateForVP9();
+  } else {
+    LOG(FATAL) << "Unknown codec type: " << codec_type;
+  }
+}
+
 }  // namespace protocol
 }  // namespace remoting