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 <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 
 namespace content {
 
 // Constraint keys. Specified by draft-alvestrand-constraints-resolution-00b
 const char MediaStreamVideoSource::kMinAspectRatio[] = "minAspectRatio";
 const char MediaStreamVideoSource::kMaxAspectRatio[] = "maxAspectRatio";
 const char MediaStreamVideoSource::kMaxWidth[] = "maxWidth";
 const char MediaStreamVideoSource::kMinWidth[] = "minWidth";
 const char MediaStreamVideoSource::kMaxHeight[] = "maxHeight";
@@ skipping 245 matching lines @@
 
 // Empty method used for keeping a reference to the original media::VideoFrame
 // in MediaStreamVideoSource::DeliverVideoFrame if cropping is needed.
 // The reference to |frame| is kept in the closure that calls this method.
 void ReleaseOriginalFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
 }
 
 }  // 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() {
 }
 
 void MediaStreamVideoSource::AddTrack(
-    const blink::WebMediaStreamTrack& track,
+    MediaStreamVideoTrack* track,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
   DCHECK(CalledOnValidThread());
-  requested_constraints_.push_back(RequestedConstraints(constraints,
-                                                        callback));
+  DCHECK(std::find(tracks_.begin(), tracks_.end(),
+                   track) == tracks_.end());
+  tracks_.push_back(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.
       int max_requested_width = 0;
       GetConstraintValue(constraints, true, kMaxWidth, &max_requested_width);
 
       int max_requested_height = 0;
       GetConstraintValue(constraints, true, kMaxHeight, &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 |callback| will be triggered once the source has started or
       // the capabilities have 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) {
   scoped_refptr<media::VideoFrame> video_frame(frame);
 
   if (frame->visible_rect().size() != frame_output_size_) {
     // If |frame| is not the size that is expected, we need to crop it by
     // providing a new |visible_rect|. The new visible rect must be within the
     // original |visible_rect|.
@@ skipping 19 matching lines @@
     gfx::Rect rect(horiz_crop, vert_crop, visible_width, visible_height);
     video_frame = media::VideoFrame::WrapVideoFrame(
         frame, rect, base::Bind(&ReleaseOriginalFrame, frame));
   }
 
   if ((frame->format() == media::VideoFrame::I420 ||
        frame->format() == media::VideoFrame::YV12) &&
       capture_adapter_) {
     capture_adapter_->OnFrameCaptured(video_frame);
   }
+
+  for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
+       it != tracks_.end(); ++it) {
+    (*it)->OnVideoFrame(video_frame);
+  }
 }
 
 void MediaStreamVideoSource::OnSupportedFormats(
     const media::VideoCaptureFormats& formats) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
   supported_formats_ = formats;
   if (!FindBestFormatWithConstraints(supported_formats_,
                                      &current_format_,
@@ skipping 59 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