Reland of Make cricket::VideoCapturer implement VideoSourceInterface (patchset #14 id:30000…

webrtc/media/base/videocapturer.cc

 /*
  *  Copyright (c) 2010 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 84 matching lines @@
       apply_rotation_(true) {
   Construct();
 }
 
 void VideoCapturer::Construct() {
   ClearAspectRatio();
   enable_camera_list_ = false;
   square_pixel_aspect_ratio_ = false;
   capture_state_ = CS_STOPPED;
   SignalFrameCaptured.connect(this, &VideoCapturer::OnFrameCaptured);
+  // TODO(perkj) SignalVideoFrame is used directly by Chrome remoting.
+  // Before that is refactored, SignalVideoFrame must forward frames to the
+  // |VideoBroadcaster|;
+  SignalVideoFrame.connect(this, &VideoCapturer::OnFrame);
   scaled_width_ = 0;
   scaled_height_ = 0;
   muted_ = false;
   black_frame_count_down_ = kNumBlackFramesOnMute;
   enable_video_adapter_ = true;
   adapt_frame_drops_ = 0;
   previous_frame_time_ = 0.0;
 #ifdef HAVE_WEBRTC_VIDEO
   // There are lots of video capturers out there that don't call
   // set_frame_factory.  We can either go change all of them, or we
@@ skipping 104 matching lines @@
     black_frame_count_down_ = kNumBlackFramesOnMute;
     // Following frames will be overritten with black, then the camera will be
     // paused.
     return true;
   }
   // Start the camera.
   thread_->Clear(this, MSG_DO_PAUSE);
   return Pause(false);
 }
 
-// Note that the last caller decides whether rotation should be applied if there
-// are multiple send streams using the same camera.
-bool VideoCapturer::SetApplyRotation(bool enable) {
-  apply_rotation_ = enable;
-  if (frame_factory_) {
-    frame_factory_->SetApplyRotation(apply_rotation_);
-  }
-  return true;
-}
-
 void VideoCapturer::SetSupportedFormats(
     const std::vector<VideoFormat>& formats) {
   supported_formats_ = formats;
   UpdateFilteredSupportedFormats();
 }
 
 bool VideoCapturer::GetBestCaptureFormat(const VideoFormat& format,
                                          VideoFormat* best_format) {
   // TODO(fbarchard): Directly support max_format.
   UpdateFilteredSupportedFormats();
@@ skipping 67 matching lines @@
                              VideoFormat* last_captured_frame_format) {
   rtc::CritScope cs(&frame_stats_crit_);
   GetVariableSnapshot(adapt_frame_drops_data_, adapt_drops_stats);
   GetVariableSnapshot(frame_time_data_, frame_time_stats);
   *last_captured_frame_format = last_captured_frame_format_;
 
   adapt_frame_drops_data_.Reset();
   frame_time_data_.Reset();
 }
 
+void VideoCapturer::RemoveSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink) {
+  broadcaster_.RemoveSink(sink);
+}
+
+void VideoCapturer::AddOrUpdateSink(
+    rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
+    const rtc::VideoSinkWants& wants) {
+  broadcaster_.AddOrUpdateSink(sink, wants);
+  OnSinkWantsChanged(broadcaster_.wants());
+}
+
+void VideoCapturer::OnSinkWantsChanged(const rtc::VideoSinkWants& wants) {
+  apply_rotation_ = wants.rotation_applied;
+  if (frame_factory_) {
+    frame_factory_->SetApplyRotation(apply_rotation_);
+  }
+}
+
 void VideoCapturer::OnFrameCaptured(VideoCapturer*,
                                     const CapturedFrame* captured_frame) {
   if (muted_) {
     if (black_frame_count_down_ == 0) {
       thread_->Post(this, MSG_DO_PAUSE, NULL);
     } else {
       --black_frame_count_down_;
     }
   }
 
-  if (SignalVideoFrame.is_empty()) {
+  if (!broadcaster_.frame_wanted()) {
     return;
   }
 
   // Use a temporary buffer to scale
   rtc::scoped_ptr<uint8_t[]> scale_buffer;
 
   if (IsScreencast()) {
     int scaled_width, scaled_height;
     int desired_screencast_fps = capture_format_.get() ?
       VideoFormat::IntervalToFps(capture_format_->interval) :
@@ skipping 163 matching lines @@
                   << "From " << ToString(captured_frame) << " To "
                   << cropped_width << " x " << cropped_height;
     return;
   }
 
   if (muted_) {
     // TODO(pthatcher): Use frame_factory_->CreateBlackFrame() instead.
     adapted_frame->SetToBlack();
   }
   SignalVideoFrame(this, adapted_frame.get());
+  UpdateStats(captured_frame);
+}
 
-  UpdateStats(captured_frame);
+void VideoCapturer::OnFrame(VideoCapturer* capturer, const VideoFrame* frame) {
+  broadcaster_.OnFrame(*frame);
 }
 
 void VideoCapturer::SetCaptureState(CaptureState state) {
   if (state == capture_state_) {
     // Don't trigger a state changed callback if the state hasn't changed.
     return;
   }
   StateChangeParams* state_params = new StateChangeParams(state);
   capture_state_ = state;
   thread_->Post(this, MSG_STATE_CHANGE, state_params);
@@ skipping 170 matching lines @@
 void VideoCapturer::GetVariableSnapshot(
     const rtc::RollingAccumulator<T>& data,
     VariableInfo<T>* stats) {
   stats->max_val = data.ComputeMax();
   stats->mean = data.ComputeMean();
   stats->min_val = data.ComputeMin();
   stats->variance = data.ComputeVariance();
 }
 
 }  // namespace cricket