Add WebrtcVideoEncoder interface

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 "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/proto/video.pb.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_transport.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 #include "third_party/webrtc/media/base/videocapturer.h"
 
 namespace remoting {
@@ skipping 29 matching lines @@
   base::TimeTicks input_event_received_time;
 
   base::TimeTicks capture_started_time;
   base::TimeTicks capture_ended_time;
   base::TimeDelta capture_delay;
   base::TimeTicks encode_started_time;
   base::TimeTicks encode_ended_time;
 };
 
 struct WebrtcVideoStream::EncodedFrameWithTimestamps {
-  std::unique_ptr<VideoPacket> frame;
+  std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame;
   std::unique_ptr<FrameTimestamps> timestamps;
 };
 
 WebrtcVideoStream::WebrtcVideoStream()
     : video_stats_dispatcher_(kStreamLabel), weak_factory_(this) {}
 
 WebrtcVideoStream::~WebrtcVideoStream() {
   if (stream_) {
     for (const auto& track : stream_->GetVideoTracks()) {
       stream_->RemoveTrack(track.get());
     }
     peer_connection_->RemoveStream(stream_.get());
   }
   encode_task_runner_->DeleteSoon(FROM_HERE, encoder_.release());
 }
 
 bool WebrtcVideoStream::Start(
     std::unique_ptr<webrtc::DesktopCapturer> desktop_capturer,
     WebrtcTransport* webrtc_transport,
-    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
-    std::unique_ptr<VideoEncoder> video_encoder) {
+    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(webrtc_transport);
   DCHECK(desktop_capturer);
   DCHECK(encode_task_runner);
-  DCHECK(video_encoder);
 
   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_ = encode_task_runner;
   capturer_ = std::move(desktop_capturer);
   webrtc_transport_ = webrtc_transport;
-  encoder_ = std::move(video_encoder);
+  // TODO(isheriff): make this codec independent
+  encoder_ = WebrtcVideoEncoderVpx::CreateForVP8();
   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 120 matching lines @@
     frame_dpi_ = dpi;
     if (observer_)
       observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
   }
 
   captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
   captured_frame_timestamps_->capture_delay =
       base::TimeDelta::FromMilliseconds(frame->capture_time_ms());
 
   encode_pending_ = true;
+
+  // TODO(sergeyu): Currently frame_duration is always set to 1/15 of a second.
+  // Experiment with different values, and try changing it dynamically.
+  WebrtcVideoEncoder::FrameParams frame_params;
+  frame_params.bitrate_kbps = target_bitrate_kbps_;
+  frame_params.duration = base::TimeDelta::FromSeconds(1) / 15;
+  frame_params.key_frame = ClearAndGetKeyFrameRequest();
+
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebrtcVideoStream::EncodeFrame, encoder_.get(),
-                 base::Passed(std::move(frame)),
-                 base::Passed(std::move(captured_frame_timestamps_)),
-                 target_bitrate_kbps_, ClearAndGetKeyFrameRequest()),
+                 base::Passed(std::move(frame)), frame_params,
+                 base::Passed(std::move(captured_frame_timestamps_))),
       base::Bind(&WebrtcVideoStream::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcVideoStream::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
 }
 void WebrtcVideoStream::OnChannelClosed(
     ChannelDispatcherBase* channel_dispatcher) {
@@ skipping 25 matching lines @@
     next_frame_timestamps_.reset(new FrameTimestamps());
 
   captured_frame_timestamps_ = std::move(next_frame_timestamps_);
   captured_frame_timestamps_->capture_started_time = now;
 
   capturer_->Capture(webrtc::DesktopRegion());
 }
 
 // static
 WebrtcVideoStream::EncodedFrameWithTimestamps WebrtcVideoStream::EncodeFrame(
-    VideoEncoder* encoder,
+    WebrtcVideoEncoder* encoder,
     std::unique_ptr<webrtc::DesktopFrame> frame,
-    std::unique_ptr<WebrtcVideoStream::FrameTimestamps> timestamps,
-    uint32_t target_bitrate_kbps,
-    bool key_frame_request) {
+    WebrtcVideoEncoder::FrameParams params,
+    std::unique_ptr<WebrtcVideoStream::FrameTimestamps> timestamps) {
   EncodedFrameWithTimestamps result;
   result.timestamps = std::move(timestamps);
   result.timestamps->encode_started_time = base::TimeTicks::Now();
-
-  encoder->UpdateTargetBitrate(target_bitrate_kbps);
-  result.frame = encoder->Encode(
-      *frame, key_frame_request ? VideoEncoder::REQUEST_KEY_FRAME : 0);
-
+  result.frame = encoder->Encode(*frame, params);
   result.timestamps->encode_ended_time = base::TimeTicks::Now();
-
   return result;
 }
 
 void WebrtcVideoStream::OnFrameEncoded(EncodedFrameWithTimestamps frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   encode_pending_ = false;
 
-  size_t frame_size = frame.frame ? frame.frame->data().size() : 0;
+  size_t frame_size = frame.frame ? frame.frame->data.size() : 0;
 
   // Generate HostFrameStats.
   HostFrameStats stats;
   stats.frame_size = frame_size;
 
   if (!frame.timestamps->input_event_received_time.is_null()) {
     stats.capture_pending_delay = frame.timestamps->capture_started_time -
                                   frame.timestamps->input_event_received_time;
     stats.latest_event_timestamp = base::TimeTicks::FromInternalValue(
         frame.timestamps->input_event_client_timestamp);
@@ skipping 39 matching lines @@
   float encoded_bits = frame_size * 8.0;
   uint32_t next_sched_ms = std::max(
       33, std::min(static_cast<int>(encoded_bits / target_bitrate_kbps_), 200));
   capture_timer_.Start(FROM_HERE,
                        base::TimeDelta::FromMilliseconds(next_sched_ms), this,
                        &WebrtcVideoStream::CaptureNextFrame);
 }
 
 }  // namespace protocol
 }  // namespace remoting