Implement a source for remote video tracks.

content/renderer/media/webrtc/media_stream_remote_video_source.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_remote_video_source.h"
+
+#include "base/bind.h"
+#include "base/location.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"
+
+namespace content {
+
+MediaStreamRemoteVideoSource::MediaStreamRemoteVideoSource(
+    webrtc::VideoTrackInterface* remote_track)
+    : MediaStreamVideoSource(NULL),
+      message_loop_proxy_(base::MessageLoopProxy::current()),
+      remote_track_(remote_track),
+      track_state_(remote_track_->state()),

[Jói, 2014/03/17 22:00:40]

As a minor suggestion, perhaps this should be called last_state_ as a way to
self-document that this is used to detect changes in state?

[Ronghua Wu (Left Chromium), 2014/03/17 22:45:35]

+1

[perkj_chrome, 2014/03/19 16:34:48]

Done.

[perkj_chrome, 2014/03/19 16:34:48]

Done.

+      first_frame_received_(false) {
+  remote_track_->AddRenderer(this);
+  remote_track_->RegisterObserver(this);
+}
+
+MediaStreamRemoteVideoSource::~MediaStreamRemoteVideoSource() {
+  StopSourceImpl();
+}
+
+void MediaStreamRemoteVideoSource::GetCurrentSupportedFormats(
+    int max_requested_width,
+    int max_requested_height) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  if (format_.IsValid()) {

[Jói, 2014/03/17 22:00:40]

If format_ is not valid, is it acceptable to never call OnSupportedFormats?

[Ronghua Wu (Left Chromium), 2014/03/17 22:45:35]

Should call OnSupportedFormats regardless, otherwise the caller will be waiting
for the callback forever.

[perkj_chrome, 2014/03/19 16:34:48]

So the idea here is that format_ gets valid when the first video frame is
received. But that will typically happen after the remote SDP has been received
and the new remote track has been announced.

+    media::VideoCaptureFormats formats;
+    formats.push_back(format_);
+    OnSupportedFormats(formats);
+  }
+}
+
+void MediaStreamRemoteVideoSource::StartSourceImpl(
+    const media::VideoCaptureParams& params) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  OnStartDone(true);
+}
+
+void MediaStreamRemoteVideoSource::StopSourceImpl() {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  remote_track_->RemoveRenderer(this);
+  remote_track_->UnregisterObserver(this);
+}
+
+webrtc::VideoSourceInterface* MediaStreamRemoteVideoSource::GetAdapter() {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  return remote_track_->GetSource();
+}
+
+void MediaStreamRemoteVideoSource::SetSize(int width, int height) {
+}
+
+void MediaStreamRemoteVideoSource::RenderFrame(
+    const cricket::VideoFrame* frame) {
+  base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(

[Jói, 2014/03/17 22:00:40]

Note that there is also a FromMicroseconds factory, in case that would provide
better precision.

[perkj_chrome, 2014/03/19 16:34:48]

Except that I introduce the video frame pool I kept the rendering part the same
as we have had a long time. Right now its from webrtc_video_sink_adapter.cc and
previously somewhere else. So thanks- but ms precision is good enough. (btw, I
found out that this is currently only used for showing the time in seconds in a
<video>

+      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 = frame_pool_.CreateFrame(
+        media::VideoFrame::I420, size, gfx::Rect(size), size, timestamp);
+
+    // Aspect ratio unsupported; DCHECK when there are non-square pixels.

[Ronghua Wu (Left Chromium), 2014/03/17 22:45:35]

how do you mean by "Aspect ratio unsupported"?

[perkj_chrome, 2014/03/19 16:34:48]

This function is actually copied from the one I think you wrote originally and
that has been modified by others. I simplified the comment.

+    DCHECK_EQ(frame->GetPixelWidth(), 1u);
+    DCHECK_EQ(frame->GetPixelHeight(), 1u);

[Ronghua Wu (Left Chromium), 2014/03/17 22:45:35]

why is this check needed?

+
+    int y_rows = frame->GetHeight();
+    int uv_rows = frame->GetChromaHeight();
+    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());
+  }
+
+  if (!first_frame_received_) {
+    first_frame_received_ = true;
+    media::VideoPixelFormat pixel_format = (
+        video_frame->format() == media::VideoFrame::I420) ?
+            media::PIXEL_FORMAT_I420 : media::PIXEL_FORMAT_TEXTURE;
+    media::VideoCaptureFormat format(
+        gfx::Size(video_frame->natural_size().width(),
+                  video_frame->natural_size().height()),
+        MediaStreamVideoSource::kDefaultFrameRate,
+        pixel_format);
+    message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&MediaStreamRemoteVideoSource::FrameFormatOnMainThread,
+                   AsWeakPtr(), format));
+  }
+
+  // TODO(perkj): Consider delivering the frame on whatever thread the frame is
+  // delivered on once crbug/335327 is fixed.
+  message_loop_proxy_->PostTask(

[Ronghua Wu (Left Chromium), 2014/03/17 22:45:35]

Don't deliver the frame before the source is started.

[perkj_chrome, 2014/03/19 16:34:48]

ok- But we need to do that on the correct thread. Added to
:DoRenderFrameOnMainThread. 

+      FROM_HERE,
+      base::Bind(&MediaStreamRemoteVideoSource::DoRenderFrameOnMainThread,
+                 AsWeakPtr(), video_frame));
+}
+
+void MediaStreamRemoteVideoSource::OnChanged() {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  webrtc::MediaStreamTrackInterface::TrackState state = remote_track_->state();
+  if (state != track_state_) {
+    track_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:
+        SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
+        break;
+      case webrtc::MediaStreamTrackInterface::kEnded:
+        SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+}
+
+void MediaStreamRemoteVideoSource::FrameFormatOnMainThread(
+    const media::VideoCaptureFormat& format) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  format_ = format;
+  if (GetState() == RETRIEVING_CAPABILITIES) {
+    media::VideoCaptureFormats formats;
+    formats.push_back(format);
+    OnSupportedFormats(formats);
+  }
+}
+
+void MediaStreamRemoteVideoSource::DoRenderFrameOnMainThread(
+    scoped_refptr<media::VideoFrame> video_frame) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  DeliverVideoFrame(video_frame);
+}
+
+}  // namespace content