Chrome MediaStream VideoTrack implementation.

content/renderer/media/media_stream_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/media_stream_video_source.h"
 
 #include <limits>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 196 matching lines @@
     if (diff < best_diff) {
       best_diff = diff;
       best_it = it;
     }
   }
   return *best_it;
 }
 
 }  // anonymous namespace
 
+// static
+MediaStreamVideoSource* MediaStreamVideoSource::GetVideoSource(
+    const blink::WebMediaStreamSource& source) {
+  return static_cast<MediaStreamVideoSource*>(source.extraData());
+}
+
 MediaStreamVideoSource::MediaStreamVideoSource(
     MediaStreamDependencyFactory* factory)
     : state_(NEW),
       factory_(factory),
       capture_adapter_(NULL) {
   DCHECK(factory_);
 }
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
+  DVLOG(3) << "~MediaStreamVideoSource()";
 }
 
 void MediaStreamVideoSource::AddTrack(
     const blink::WebMediaStreamTrack& track,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
   DCHECK(CalledOnValidThread());
-  requested_constraints_.push_back(RequestedConstraints(constraints,
-                                                        callback));
+  MediaStreamVideoTrack* video_track =
+      MediaStreamVideoTrack::GetVideoTrack(track);
+  DCHECK(std::find(tracks_.begin(), tracks_.end(),
+                   video_track) == tracks_.end());
+  tracks_.push_back(video_track);
+
+  requested_constraints_.push_back(
+      RequestedConstraints(constraints, callback));
+
   switch (state_) {
     case NEW: {
       // Tab capture and Screen capture needs the maximum requested height
       // and width to decide on the resolution.
       blink::WebString max_width;
       int max_requested_width = 0;
       if (constraints.getMandatoryConstraintValue(kMaxWidth, max_width))
         base::StringToInt(max_width.utf8(), &max_requested_width);
 
       int max_requested_height = 0;
       blink::WebString max_height;
       if (constraints.getMandatoryConstraintValue(kMaxHeight, max_height))
         base::StringToInt(max_height.utf8(), &max_requested_height);
 
       state_ = RETRIEVING_CAPABILITIES;
       GetCurrentSupportedFormats(max_requested_width,
                                  max_requested_height);
 
       break;
     }
     case STARTING:
     case RETRIEVING_CAPABILITIES: {
-      // The |callback| will be triggered once the delegate has started or
-      // the capabilitites has been retrieved.
+      // The |callback| will be triggered once the source has started or
+      // the capabilities has been retrieved.
       break;
     }
     case ENDED:
     case STARTED: {
       // Currently, reconfiguring the source is not supported.
       FinalizeAddTrack();
     }
   }
 }
 
-void MediaStreamVideoSource::RemoveTrack(
-    const blink::WebMediaStreamTrack& track) {
-  // TODO(ronghuawu): What should be done here? Do we really need RemoveTrack?
+void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
+  std::vector<MediaStreamVideoTrack*>::iterator it =
+      std::find(tracks_.begin(), tracks_.end(), video_track);
+  DCHECK(it != tracks_.end());
+  tracks_.erase(it);
 }
 
 void MediaStreamVideoSource::InitAdapter() {
   if (adapter_)
     return;
   // Create the webrtc::MediaStreamVideoSourceInterface adapter.
   // It needs the constraints so that constraints used by a PeerConnection
   // will be available such as constraints for CPU adaptation and a tab
   // capture.
   bool is_screeencast =
       device_info().device.type == MEDIA_TAB_VIDEO_CAPTURE ||
       device_info().device.type == MEDIA_DESKTOP_VIDEO_CAPTURE;
   capture_adapter_ = factory_->CreateVideoCapturer(is_screeencast);
   capture_adapter_->SetRequestedFormat(current_format_);
   adapter_ = factory_->CreateVideoSource(capture_adapter_,
                                          current_constraints_);
 }
 
 webrtc::VideoSourceInterface* MediaStreamVideoSource::GetAdapter() {
   if (!adapter_) {
     InitAdapter();
   }
   return adapter_;
 }
 
 void MediaStreamVideoSource::DoStopSource() {
   DVLOG(3) << "DoStopSource()";
   StopSourceImpl();
   state_ = ENDED;
+  SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
 }
 
 void MediaStreamVideoSource::DeliverVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   if (capture_adapter_)
     capture_adapter_->OnFrameCaptured(frame);
+
+  for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();

[Ronghua Wu (Left Chromium), 2014/03/01 01:26:04]

should we do this if capture_adapter_ is not null? Will a track gets 2 copies of
frames?

[perkj_chrome, 2014/03/02 09:20:44]

No- capture_adapter_ provides frames to the webrtc::MediaStreamVideoSource. It
has nothing to do with chromes MediaStreamVideoTracks. 

[Ronghua Wu (Left Chromium), 2014/03/04 01:04:11]

Assume you meant webrtc::VideoSource. So you are saying the tracks that are got
feeded by webrtc::VideoSource won't be connected to MediaStreamVideoSource? 

I thought the point is to move stuff from webrtc::VideoSource to
MediaStreamVideoSource.

[perkj_chrome, 2014/03/04 10:44:51]

Currently they work in parallell. ie video frames are fed:
MediaStreamVideoSource->capture_adapter_->libjingle
MediaStreamVideoSource->MediaSteamVideoTrack->sinks.

In the desig document we have written that we should consider doing
MediaStreamVideoSource->MediaSteamVideoTrack->capture_adapter_->libjingle

+       it != tracks_.end(); ++it) {
+    (*it)->OnVideoFrame(frame);
+  }
 }
 
 void MediaStreamVideoSource::OnSupportedFormats(
     const media::VideoCaptureFormats& formats) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
   supported_formats_ = formats;
   if (!FindBestFormatWithConstraints(supported_formats_, &current_format_,
                       &current_constraints_)) {
@@ skipping 53 matching lines @@
 }
 
 void MediaStreamVideoSource::FinalizeAddTrack() {
   media::VideoCaptureFormats formats;
   formats.push_back(current_format_);
 
   std::vector<RequestedConstraints> callbacks;
   callbacks.swap(requested_constraints_);
   for (std::vector<RequestedConstraints>::iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
+
     bool success = state_ == STARTED &&
-                   !FilterFormats(it->constraints, formats).empty();
+        !FilterFormats(it->constraints, formats).empty();
     DVLOG(3) << "FinalizeAddTrack() success " << success;
     if (!it->callback.is_null())
       it->callback.Run(this, success);
   }
 }
 
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   if (!owner().isNull()) {
     owner().setReadyState(state);
   }
-  // TODO(perkj): Notify all registered tracks.
+  for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
+       it != tracks_.end(); ++it) {
+    (*it)->OnReadyStateChanged(state);
+  }
 }
 
 MediaStreamVideoSource::RequestedConstraints::RequestedConstraints(
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback)
     : constraints(constraints), callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content