Add VideoTrackSink interface to content/public

content/renderer/media/webrtc_videosink_adapter.cc

+// Copyright (c) 2013 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_videosink_adapter.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "content/renderer/media/native_handle_impl.h"
+#include "media/base/video_frame.h"
+#include "media/base/video_util.h"
+#include "third_party/libjingle/source/talk/media/base/videoframe.h"
+#include "ui/gfx/size.h"
+
+using media::CopyYPlane;
+using media::CopyUPlane;
+using media::CopyVPlane;
+
+namespace content {
+
+WebRtcVideoSinkAdapter::WebRtcVideoSinkAdapter(
+    webrtc::VideoTrackInterface* video_track,
+    VideoTrackSink* sink)
+    : message_loop_proxy_(base::MessageLoopProxy::current()),
+      sink_(sink),
+      video_track_(video_track) {
+  DCHECK(sink);
+  video_track_->AddRenderer(this);

[Alpha Left Google, 2013/11/26 04:59:32]

Oh boy. Please tell me that this is temporary. The implementation seems to be
adding the sink to libjingle's implementation of VideoTrackInterface. I thought
we're having less dependencies on libjingle?

We already have a VideoCaptureImpl in Chrome that does multiplexing so attaching
the sink there would be the best, isn't it?

[perkj_chrome, 2013/11/26 09:16:38]

Yes- this is the first step. We will need this for remote video tracks in the
end but not for local video tracks. 
If we can use VideoCaptureImpl for multiplexing on all levels remains to be
seen. We still need a track implementation that controls enable/disable and a
source implementation to use for cloning. Ie- MediaStreams have multiple levels
of multiplexing video data. 

You can create several track using the same source from JS. (cloning of tracks)
You can add multiple sinks to a video track.

[Alpha Left Google, 2013/11/26 10:00:47]

Sounds good for this being the first step. As long as we're depending less on
libjingle I'm happy. :)

That's true. But then for video there's no modification or postprocessing of
video frame isn't it? So essentially the video frame from tracks and sources are
the same, no? I'm just thing about the performance cost of multiplexing at
multiple layers for video data. 

+  video_track_->RegisterObserver(this);
+  state_ = video_track_->state();
+  DVLOG(1) << "WebRtcVideoSinkAdapter";
+}
+
+WebRtcVideoSinkAdapter::~WebRtcVideoSinkAdapter() {
+  video_track_->RemoveRenderer(this);
+  video_track_->UnregisterObserver(this);
+  DVLOG(1) << "~WebRtcVideoSinkAdapter";
+}
+
+void WebRtcVideoSinkAdapter::SetSize(int width, int height) {
+}
+
+void WebRtcVideoSinkAdapter::RenderFrame(const cricket::VideoFrame* frame) {
+  base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
+      frame->GetTimeStamp() / talk_base::kNumNanosecsPerMillisec);
+
+  scoped_refptr<media::VideoFrame> video_frame;
+  if (frame->GetNativeHandle() != NULL) {
+    NativeHandleImpl* handle =
+        static_cast<NativeHandleImpl*>(frame->GetNativeHandle());
+    video_frame = static_cast<media::VideoFrame*>(handle->GetHandle());
+    video_frame->SetTimestamp(timestamp);
+  } else {
+    gfx::Size size(frame->GetWidth(), frame->GetHeight());
+    video_frame = media::VideoFrame::CreateFrame(
+        media::VideoFrame::YV12, size, gfx::Rect(size), size, timestamp);
+
+    // Aspect ratio unsupported; DCHECK when there are non-square pixels.
+    DCHECK_EQ(frame->GetPixelWidth(), 1u);
+    DCHECK_EQ(frame->GetPixelHeight(), 1u);
+
+    int y_rows = frame->GetHeight();
+    int uv_rows = frame->GetHeight() / 2;  // YV12 format.
+    CopyYPlane(
+        frame->GetYPlane(), frame->GetYPitch(), y_rows, video_frame.get());
+    CopyUPlane(
+        frame->GetUPlane(), frame->GetUPitch(), uv_rows, video_frame.get());
+    CopyVPlane(
+        frame->GetVPlane(), frame->GetVPitch(), uv_rows, video_frame.get());
+  }
+
+  message_loop_proxy_->PostTask(
+      FROM_HERE, base::Bind(&WebRtcVideoSinkAdapter::DoRenderFrameOnMainThread,
+                            AsWeakPtr(), video_frame));
+}
+
+void WebRtcVideoSinkAdapter::OnChanged() {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+
+  // TODO(perkj) OnChanged belong to base class of WebRtcVideoSinkAdapter
+  // common for both webrtc audio and video.
+  webrtc::MediaStreamTrackInterface::TrackState state = video_track_->state();
+  if (state == state_)
+    return;
+  state_ = state;
+  switch (state) {
+    case webrtc::MediaStreamTrackInterface::kInitializing:
+      // Ignore the kInitializing state since there is no match in
+      // WebMediaStreamSource::ReadyState.
+      break;
+    case webrtc::MediaStreamTrackInterface::kLive:
+      sink_->OnSourceChangedState(MediaTrackSink::kLive);
+      break;
+    case webrtc::MediaStreamTrackInterface::kEnded:
+      sink_->OnSourceChangedState(MediaTrackSink::kEnded);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void WebRtcVideoSinkAdapter::DoRenderFrameOnMainThread(
+    scoped_refptr<media::VideoFrame> video_frame) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+
+  if (!sink_)
+    return;
+
+  sink_->OnVideoFrame(video_frame);
+}
+
+}  // namespace content