Implement and use VideoTrackSource directly.

content/renderer/media/webrtc/media_stream_video_webrtc_sink.cc

 // Copyright 2014 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 "content/renderer/media/webrtc/media_stream_video_webrtc_sink.h"
 
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/renderer/media_stream_utils.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "media/base/limits.h"
+#include "third_party/webrtc/api/videosourceproxy.h"
+#include "third_party/webrtc/api/videotracksource.h"
 
 namespace content {
 
+class MediaStreamVideoWebRtcSink::WebRtcVideoSource
+    : public webrtc::VideoTrackSource {
+ public:
+  WebRtcVideoSource(WebRtcVideoCapturerAdapter* capture_adapter,
+                    bool is_screencast,
+                    rtc::Optional<bool> needs_denoising)
+      : VideoTrackSource(capture_adapter, false),
+        capture_adapter_(capture_adapter),
+        is_screencast_(is_screencast),
+        needs_denoising_(needs_denoising) {}
+
+  WebRtcVideoCapturerAdapter* capture_adapter() const {
+    return capture_adapter_.get();
+  }
+
+  bool is_screencast() const override { return is_screencast_; }
+  rtc::Optional<bool> needs_denoising() const override {
+    return needs_denoising_;

[hta - Chromium, 2016/09/20 16:33:43]

Can we get the API in place to change needs_denoising_ after creation?
We're going to need that for ApplyConstraints() even if it always fails.

[pbos, 2016/09/20 17:13:47]

I'll defer that because it affects threading, as the values are const on
construction I don't have to care right now.

ApplyConstraints() is likely to have ramifications way further down the stack as
well (RtpSender needs to re-pull these options etc). Adding
set_needs_denoising() seems to only be a tiny part of it.

+  }
+
+ private:
+  std::unique_ptr<WebRtcVideoCapturerAdapter> const capture_adapter_;
+  const bool is_screencast_;
+  const rtc::Optional<bool> needs_denoising_;
+};
+
 namespace {
 
 // The default number of microseconds that should elapse since the last video
 // frame was received, before requesting a refresh frame.
 const int64_t kDefaultRefreshIntervalMicros =
     base::Time::kMicrosecondsPerSecond;
 
 // A lower-bound for the refresh interval.
 const int64_t kLowerBoundRefreshIntervalMicros =
     base::Time::kMicrosecondsPerSecond / media::limits::kMaxFramesPerSecond;
 
 }  // namespace
 
 // Simple help class used for receiving video frames on the IO-thread from a
 // MediaStreamVideoTrack and forward the frames to a WebRtcVideoCapturerAdapter
 // on libjingle's worker thread. WebRtcVideoCapturerAdapter implements a video
 // capturer for libjingle.
 class MediaStreamVideoWebRtcSink::WebRtcVideoSourceAdapter
     : public base::RefCountedThreadSafe<WebRtcVideoSourceAdapter> {
  public:
-  WebRtcVideoSourceAdapter(
-      const scoped_refptr<base::SingleThreadTaskRunner>&
-          libjingle_worker_thread,
-      const scoped_refptr<webrtc::VideoTrackSourceInterface>& source,
-      WebRtcVideoCapturerAdapter* capture_adapter,
-      base::TimeDelta refresh_interval,
-      const base::Closure& refresh_callback);
+  WebRtcVideoSourceAdapter(const scoped_refptr<base::SingleThreadTaskRunner>&
+                               libjingle_worker_thread,
+                           const scoped_refptr<WebRtcVideoSource>& source,
+                           base::TimeDelta refresh_interval,
+                           const base::Closure& refresh_callback);
 
   // MediaStreamVideoWebRtcSink can be destroyed on the main render thread or
   // libjingles worker thread since it posts video frames on that thread. But
   // |video_source_| must be released on the main render thread before the
   // PeerConnectionFactory has been destroyed. The only way to ensure that is to
   // make sure |video_source_| is released when MediaStreamVideoWebRtcSink() is
   // destroyed.
   void ReleaseSourceOnMainThread();
 
   void OnVideoFrameOnIO(const scoped_refptr<media::VideoFrame>& frame,
@@ skipping 41 matching lines @@
   // remote clients that join a distributed session receive a first video frame
   // in a timely manner. Second, it will allow WebRTC's internal bandwidth
   // estimation logic to maintain a more optimal state, since sending a video
   // frame will "prime it." Third, it allows lossy encoders to clean up
   // artifacts in a still image.  http://crbug.com/486274
   base::RepeatingTimer refresh_timer_;
 };
 
 MediaStreamVideoWebRtcSink::WebRtcVideoSourceAdapter::WebRtcVideoSourceAdapter(
     const scoped_refptr<base::SingleThreadTaskRunner>& libjingle_worker_thread,
-    const scoped_refptr<webrtc::VideoTrackSourceInterface>& source,
-    WebRtcVideoCapturerAdapter* capture_adapter,
+    const scoped_refptr<WebRtcVideoSource>& source,
     base::TimeDelta refresh_interval,
     const base::Closure& refresh_callback)
     : render_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       libjingle_worker_thread_(libjingle_worker_thread),
       video_source_(source),
-      capture_adapter_(capture_adapter) {
+      capture_adapter_(source->capture_adapter()) {
   io_thread_checker_.DetachFromThread();
   if (!refresh_interval.is_zero()) {
     VLOG(1) << "Starting frame refresh timer with interval "
             << refresh_interval.InMillisecondsF() << " ms.";
     refresh_timer_.Start(FROM_HERE, refresh_interval, refresh_callback);
   }
 }
 
 MediaStreamVideoWebRtcSink::WebRtcVideoSourceAdapter::
     ~WebRtcVideoSourceAdapter() {
@@ skipping 54 matching lines @@
     : weak_factory_(this) {
   const blink::WebMediaConstraints& constraints =
       MediaStreamVideoTrack::GetVideoTrack(track)->constraints();
 
   // Check for presence of mediaStreamSource constraint. The value is ignored.
   std::string value;
   bool is_screencast = GetConstraintValueAsString(
       constraints, &blink::WebMediaTrackConstraintSet::mediaStreamSource,
       &value);
 
+  // Extract denoising preference, if no value is set this currently falls back
+  // to a codec-specific default inside webrtc, hence the tri-state of {on, off
+  // unset}.
+  rtc::Optional<bool> needs_denoising;
+  bool denoising_value;
+  if (GetConstraintValueAsBoolean(
+          constraints, &blink::WebMediaTrackConstraintSet::googNoiseReduction,
+          &denoising_value)) {
+    needs_denoising = rtc::Optional<bool>(denoising_value);
+  }
+
   // Enable automatic frame refreshes for the screen capture sources, which will
   // stop producing frames whenever screen content is not changing. Check the
   // frameRate constraint to determine the rate of refreshes. If a minimum
   // frameRate is provided, use that. Otherwise, use the maximum frameRate if it
   // happens to be less than the default.
   base::TimeDelta refresh_interval = base::TimeDelta::FromMicroseconds(0);
   if (is_screencast) {
     // Start with the default refresh interval, and refine based on constraints.
     refresh_interval =
         base::TimeDelta::FromMicroseconds(kDefaultRefreshIntervalMicros);
@@ skipping 14 matching lines @@
           base::TimeDelta::FromMicroseconds(base::saturated_cast<int64_t>(
               base::Time::kMicrosecondsPerSecond / value));
       refresh_interval = std::max(refresh_interval, alternate_refresh_interval);
     }
     if (refresh_interval.InMicroseconds() < kLowerBoundRefreshIntervalMicros) {
       refresh_interval =
           base::TimeDelta::FromMicroseconds(kLowerBoundRefreshIntervalMicros);
     }
   }
 
-  WebRtcVideoCapturerAdapter* capture_adapter =
-      factory->CreateVideoCapturer(is_screencast);
+  // TODO(pbos): Consolidate WebRtcVideoCapturerAdapter into WebRtcVideoSource
+  // by removing the need for and dependency on a circket::VideoCapturer.

[hta - Chromium, 2016/09/20 16:33:43]

spelling: circket -> cricket

[pbos, 2016/09/20 17:13:47]

Done.

+  video_source_ = scoped_refptr<WebRtcVideoSource>(
+      new rtc::RefCountedObject<WebRtcVideoSource>(
+          new WebRtcVideoCapturerAdapter(is_screencast), is_screencast,
+          needs_denoising));
 
-  // |video_source| owns |capture_adapter|
-  scoped_refptr<webrtc::VideoTrackSourceInterface> video_source(
-      factory->CreateVideoSource(capture_adapter));
-
+  // TODO(pbos): Consolidate the local video track with the source proxy and
+  // move into PeerConnectionDependencyFactory. This now separately holds on a
+  // reference to the proxy object because
+  // PeerConnectionFactory::CreateVideoTrack doesn't do reference counting.
+  video_source_proxy_ =
+      factory->CreateVideoTrackSourceProxy(video_source_.get());
   video_track_ = factory->CreateLocalVideoTrack(track.id().utf8(),
-                                                video_source.get());
+                                                video_source_proxy_.get());
 
   video_track_->set_enabled(track.isEnabled());
 
   source_adapter_ = new WebRtcVideoSourceAdapter(
-      factory->GetWebRtcWorkerThread(),
-      video_source,
-      capture_adapter,
-      refresh_interval,
+      factory->GetWebRtcWorkerThread(), video_source_.get(), refresh_interval,
       base::Bind(&MediaStreamVideoWebRtcSink::RequestRefreshFrame,
                  weak_factory_.GetWeakPtr()));
 
   MediaStreamVideoSink::ConnectToTrack(
       track,
       base::Bind(&WebRtcVideoSourceAdapter::OnVideoFrameOnIO, source_adapter_),
       false);
 
   DVLOG(3) << "MediaStreamVideoWebRtcSink ctor() : is_screencast "
            << is_screencast;
@@ skipping 11 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   video_track_->set_enabled(enabled);
 }
 
 void MediaStreamVideoWebRtcSink::RequestRefreshFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   content::RequestRefreshFrameFromVideoTrack(connected_track());
 }
 
 }  // namespace content