Revert of Removed unused cricket::VideoCapturer methods

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.
  */
 
 // Implementation file of class VideoCapturer.
 
 #include "webrtc/media/base/videocapturer.h"
 
 #include <algorithm>
 
 #include "libyuv/scale_argb.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/systeminfo.h"
 #include "webrtc/media/base/videoframefactory.h"
+
+#if defined(HAVE_WEBRTC_VIDEO)
 #include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/media/engine/webrtcvideoframefactory.h"
+#endif  // HAVE_WEBRTC_VIDEO
 
 namespace cricket {
 
 namespace {
 
+// TODO(thorcarpenter): This is a BIG hack to flush the system with black
+// frames. Frontends should coordinate to update the video state of a muted
+// user. When all frontends to this consider removing the black frame business.
+const int kNumBlackFramesOnMute = 30;
+
+// MessageHandler constants.
+enum {
+  MSG_DO_PAUSE = 0,
+  MSG_DO_UNPAUSE,
+  MSG_STATE_CHANGE
+};
+
 static const int64_t kMaxDistance = ~(static_cast<int64_t>(1) << 63);
 #ifdef WEBRTC_LINUX
 static const int kYU12Penalty = 16;  // Needs to be higher than MJPG index.
 #endif
 static const int kDefaultScreencastFps = 5;
+typedef rtc::TypedMessageData<CaptureState> StateChangeParams;
 
 // Limit stats data collections to ~20 seconds of 30fps data before dropping
 // old data in case stats aren't reset for long periods of time.
 static const size_t kMaxAccumulatorSize = 600;
 
 }  // namespace
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of struct CapturedFrame
 /////////////////////////////////////////////////////////////////////
@@ skipping 14 matching lines @@
     return false;
   }
   *size = data_size;
   return true;
 }
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of class VideoCapturer
 /////////////////////////////////////////////////////////////////////
 VideoCapturer::VideoCapturer()
-    : adapt_frame_drops_data_(kMaxAccumulatorSize),
+    : thread_(rtc::Thread::Current()),
+      adapt_frame_drops_data_(kMaxAccumulatorSize),
       frame_time_data_(kMaxAccumulatorSize),
       apply_rotation_(true) {
-  thread_checker_.DetachFromThread();
+  Construct();
+}
+
+VideoCapturer::VideoCapturer(rtc::Thread* thread)
+    : thread_(thread),
+      adapt_frame_drops_data_(kMaxAccumulatorSize),
+      frame_time_data_(kMaxAccumulatorSize),
+      apply_rotation_(true) {
   Construct();
 }
 
 void VideoCapturer::Construct() {
-  ratio_w_ = 0;
-  ratio_h_ = 0;
+  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
   // can set this default.
   // TODO(pthatcher): Remove this hack and require the frame factory
   // to be passed in the constructor.
   set_frame_factory(new WebRtcVideoFrameFactory());
+#endif
 }
 
 const std::vector<VideoFormat>* VideoCapturer::GetSupportedFormats() const {
   return &filtered_supported_formats_;
 }
 
 bool VideoCapturer::StartCapturing(const VideoFormat& capture_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   previous_frame_time_ = frame_length_time_reporter_.TimerNow();
   CaptureState result = Start(capture_format);
   const bool success = (result == CS_RUNNING) || (result == CS_STARTING);
   if (!success) {
     return false;
   }
   if (result == CS_RUNNING) {
     SetCaptureState(result);
   }
   return true;
 }
 
+void VideoCapturer::UpdateAspectRatio(int ratio_w, int ratio_h) {
+  if (ratio_w == 0 || ratio_h == 0) {
+    LOG(LS_WARNING) << "UpdateAspectRatio ignored invalid ratio: "
+                    << ratio_w << "x" << ratio_h;
+    return;
+  }
+  ratio_w_ = ratio_w;
+  ratio_h_ = ratio_h;
+}
+
+void VideoCapturer::ClearAspectRatio() {
+  ratio_w_ = 0;
+  ratio_h_ = 0;
+}
+
+// Override this to have more control of how your device is started/stopped.
+bool VideoCapturer::Pause(bool pause) {
+  if (pause) {
+    if (capture_state() == CS_PAUSED) {
+      return true;
+    }
+    bool is_running = capture_state() == CS_STARTING ||
+        capture_state() == CS_RUNNING;
+    if (!is_running) {
+      LOG(LS_ERROR) << "Cannot pause a stopped camera.";
+      return false;
+    }
+    LOG(LS_INFO) << "Pausing a camera.";
+    rtc::scoped_ptr<VideoFormat> capture_format_when_paused(
+        capture_format_ ? new VideoFormat(*capture_format_) : NULL);
+    Stop();
+    SetCaptureState(CS_PAUSED);
+    // If you override this function be sure to restore the capture format
+    // after calling Stop().
+    SetCaptureFormat(capture_format_when_paused.get());
+  } else {  // Unpause.
+    if (capture_state() != CS_PAUSED) {
+      LOG(LS_WARNING) << "Cannot unpause a camera that hasn't been paused.";
+      return false;
+    }
+    if (!capture_format_) {
+      LOG(LS_ERROR) << "Missing capture_format_, cannot unpause a camera.";
+      return false;
+    }
+    if (muted_) {
+      LOG(LS_WARNING) << "Camera cannot be unpaused while muted.";
+      return false;
+    }
+    LOG(LS_INFO) << "Unpausing a camera.";
+    if (!Start(*capture_format_)) {
+      LOG(LS_ERROR) << "Camera failed to start when unpausing.";
+      return false;
+    }
+  }
+  return true;
+}
+
+bool VideoCapturer::Restart(const VideoFormat& capture_format) {
+  if (!IsRunning()) {
+    return StartCapturing(capture_format);
+  }
+
+  if (GetCaptureFormat() != NULL && *GetCaptureFormat() == capture_format) {
+    // The reqested format is the same; nothing to do.
+    return true;
+  }
+
+  Stop();
+  return StartCapturing(capture_format);
+}
+
+bool VideoCapturer::MuteToBlackThenPause(bool muted) {
+  if (muted == IsMuted()) {
+    return true;
+  }
+
+  LOG(LS_INFO) << (muted ? "Muting" : "Unmuting") << " this video capturer.";
+  muted_ = muted;  // Do this before calling Pause().
+  if (muted) {
+    // Reset black frame count down.
+    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);
+}
+
 void VideoCapturer::SetSupportedFormats(
     const std::vector<VideoFormat>& formats) {
-  // This method is OK to call during initialization on a separate thread.
-  RTC_DCHECK(capture_state_ == CS_STOPPED ||
-             thread_checker_.CalledOnValidThread());
   supported_formats_ = formats;
   UpdateFilteredSupportedFormats();
 }
 
 bool VideoCapturer::GetBestCaptureFormat(const VideoFormat& format,
                                          VideoFormat* best_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(fbarchard): Directly support max_format.
   UpdateFilteredSupportedFormats();
   const std::vector<VideoFormat>* supported_formats = GetSupportedFormats();
 
   if (supported_formats->empty()) {
     return false;
   }
   LOG(LS_INFO) << " Capture Requested " << format.ToString();
   int64_t best_distance = kMaxDistance;
   std::vector<VideoFormat>::const_iterator best = supported_formats->end();
@@ skipping 18 matching lines @@
     best_format->height = best->height;
     best_format->fourcc = best->fourcc;
     best_format->interval = best->interval;
     LOG(LS_INFO) << " Best " << best_format->ToString() << " Interval "
                  << best_format->interval << " distance " << best_distance;
   }
   return true;
 }
 
 void VideoCapturer::ConstrainSupportedFormats(const VideoFormat& max_format) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   max_format_.reset(new VideoFormat(max_format));
   LOG(LS_VERBOSE) << " ConstrainSupportedFormats " << max_format.ToString();
   UpdateFilteredSupportedFormats();
 }
 
 std::string VideoCapturer::ToString(const CapturedFrame* captured_frame) const {
   std::string fourcc_name = GetFourccName(captured_frame->fourcc) + " ";
   for (std::string::const_iterator i = fourcc_name.begin();
        i < fourcc_name.end(); ++i) {
     // Test character is printable; Avoid isprint() which asserts on negatives.
@@ skipping 23 matching lines @@
   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) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   broadcaster_.RemoveSink(sink);
 }
 
 void VideoCapturer::AddOrUpdateSink(
     rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
     const rtc::VideoSinkWants& wants) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   broadcaster_.AddOrUpdateSink(sink, wants);
   OnSinkWantsChanged(broadcaster_.wants());
 }
 
 void VideoCapturer::OnSinkWantsChanged(const rtc::VideoSinkWants& wants) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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 (!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)
-            : kDefaultScreencastFps;
+    int desired_screencast_fps = capture_format_.get() ?
+      VideoFormat::IntervalToFps(capture_format_->interval) :
+      kDefaultScreencastFps;
     ComputeScale(captured_frame->width, captured_frame->height,
                  desired_screencast_fps, &scaled_width, &scaled_height);
 
     if (FOURCC_ARGB == captured_frame->fourcc &&
         (scaled_width != captured_frame->width ||
-         scaled_height != captured_frame->height)) {
+        scaled_height != captured_frame->height)) {
       if (scaled_width != scaled_width_ || scaled_height != scaled_height_) {
-        LOG(LS_INFO) << "Scaling Screencast from " << captured_frame->width
-                     << "x" << captured_frame->height << " to " << scaled_width
-                     << "x" << scaled_height;
+        LOG(LS_INFO) << "Scaling Screencast from "
+                     << captured_frame->width << "x"
+                     << captured_frame->height << " to "
+                     << scaled_width << "x" << scaled_height;
         scaled_width_ = scaled_width;
         scaled_height_ = scaled_height;
       }
       CapturedFrame* modified_frame =
           const_cast<CapturedFrame*>(captured_frame);
       const int modified_frame_size = scaled_width * scaled_height * 4;
       scale_buffer.reset(new uint8_t[modified_frame_size]);
       // Compute new width such that width * height is less than maximum but
       // maintains original captured frame aspect ratio.
       // Round down width to multiple of 4 so odd width won't round up beyond
       // maximum, and so chroma channel is even width to simplify spatial
       // resampling.
       libyuv::ARGBScale(reinterpret_cast<const uint8_t*>(captured_frame->data),
                         captured_frame->width * 4, captured_frame->width,
                         captured_frame->height, scale_buffer.get(),
                         scaled_width * 4, scaled_width, scaled_height,
                         libyuv::kFilterBilinear);
       modified_frame->width = scaled_width;
       modified_frame->height = scaled_height;
       modified_frame->data_size = scaled_width * 4 * scaled_height;
       modified_frame->data = scale_buffer.get();
     }
   }
 
   const int kYuy2Bpp = 2;
   const int kArgbBpp = 4;
   // TODO(fbarchard): Make a helper function to adjust pixels to square.
   // TODO(fbarchard): Hook up experiment to scaling.
+  // TODO(fbarchard): Avoid scale and convert if muted.
   // Temporary buffer is scoped here so it will persist until i420_frame.Init()
   // makes a copy of the frame, converting to I420.
   rtc::scoped_ptr<uint8_t[]> temp_buffer;
   // YUY2 can be scaled vertically using an ARGB scaler.  Aspect ratio is only
   // a problem on OSX.  OSX always converts webcams to YUY2 or UYVY.
   bool can_scale =
       FOURCC_YUY2 == CanonicalFourCC(captured_frame->fourcc) ||
       FOURCC_UYVY == CanonicalFourCC(captured_frame->fourcc);
 
   // If pixels are not square, optionally use vertical scaling to make them
@@ skipping 107 matching lines @@
                                          adapted_width, adapted_height));
 
   if (!adapted_frame) {
     // TODO(fbarchard): LOG more information about captured frame attributes.
     LOG(LS_ERROR) << "Couldn't convert to I420! "
                   << "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);
 }
 
 void VideoCapturer::OnFrame(VideoCapturer* capturer, const VideoFrame* frame) {
   broadcaster_.OnFrame(*frame);
 }
 
 void VideoCapturer::SetCaptureState(CaptureState state) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   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;
-  SignalStateChange(this, capture_state_);
+  thread_->Post(this, MSG_STATE_CHANGE, state_params);
+}
+
+void VideoCapturer::OnMessage(rtc::Message* message) {
+  switch (message->message_id) {
+    case MSG_STATE_CHANGE: {
+      rtc::scoped_ptr<StateChangeParams> p(
+          static_cast<StateChangeParams*>(message->pdata));
+      SignalStateChange(this, p->data());
+      break;
+    }
+    case MSG_DO_PAUSE: {
+      Pause(true);
+      break;
+    }
+    case MSG_DO_UNPAUSE: {
+      Pause(false);
+      break;
+    }
+    default: {
+      ASSERT(false);
+    }
+  }
 }
 
 // Get the distance between the supported and desired formats.
 // Prioritization is done according to this algorithm:
 // 1) Width closeness. If not same, we prefer wider.
 // 2) Height closeness. If not same, we prefer higher.
 // 3) Framerate closeness. If not same, we prefer faster.
 // 4) Compression. If desired format has a specific fourcc, we need exact match;
 //                otherwise, we use preference.
 int64_t VideoCapturer::GetFormatDistance(const VideoFormat& desired,
                                          const VideoFormat& supported) {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   int64_t distance = kMaxDistance;
 
   // Check fourcc.
   uint32_t supported_fourcc = CanonicalFourCC(supported.fourcc);
   int64_t delta_fourcc = kMaxDistance;
   if (FOURCC_ANY == desired.fourcc) {
     // Any fourcc is OK for the desired. Use preference to find best fourcc.
     std::vector<uint32_t> preferred_fourccs;
     if (!GetPreferredFourccs(&preferred_fourccs)) {
       return distance;
@@ skipping 90 matching lines @@
   }
   if (filtered_supported_formats_.empty()) {
     // The device only captures at resolutions higher than |max_format_| this
     // indicates that |max_format_| should be ignored as it is better to capture
     // at too high a resolution than to not capture at all.
     filtered_supported_formats_ = supported_formats_;
   }
 }
 
 bool VideoCapturer::ShouldFilterFormat(const VideoFormat& format) const {
-  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!enable_camera_list_) {
     return false;
   }
   return format.width > max_format_->width ||
          format.height > max_format_->height;
 }
 
 void VideoCapturer::UpdateStats(const CapturedFrame* captured_frame) {
   // Update stats protected from fetches from different thread.
   rtc::CritScope cs(&frame_stats_crit_);
@@ skipping 17 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