Revert of Removed unused cricket::VideoCapturer methods

webrtc/media/base/videocapturer.h

 /*
  *  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.
  */
 
 // Declaration of abstract class VideoCapturer
 
 #ifndef WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_
 #define WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/media/base/videosourceinterface.h"
+#include "webrtc/base/messagehandler.h"
 #include "webrtc/base/rollingaccumulator.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/sigslot.h"
+#include "webrtc/base/thread.h"
 #include "webrtc/base/timing.h"
-#include "webrtc/base/thread_checker.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/base/videoadapter.h"
 #include "webrtc/media/base/videobroadcaster.h"
 #include "webrtc/media/base/videocommon.h"
 #include "webrtc/media/base/videoframefactory.h"
 #include "webrtc/media/devices/devicemanager.h"
 
 
 namespace cricket {
 
 // Current state of the capturer.
+// TODO(hellner): CS_NO_DEVICE is an error code not a capture state. Separate
+//                error codes and states.
 enum CaptureState {
   CS_STOPPED,    // The capturer has been stopped or hasn't started yet.
   CS_STARTING,   // The capturer is in the process of starting. Note, it may
                  // still fail to start.
   CS_RUNNING,    // The capturer has been started successfully and is now
                  // capturing.
   CS_PAUSED,     // The capturer has been paused.
   CS_FAILED,     // The capturer failed to start.
+  CS_NO_DEVICE,  // The capturer has no device and consequently failed to start.
 };
 
 class VideoFrame;
 
 struct CapturedFrame {
   static const uint32_t kFrameHeaderSize = 40;  // Size from width to data_size.
   static const uint32_t kUnknownDataSize = 0xFFFFFFFF;
 
   CapturedFrame();
 
@@ skipping 23 matching lines @@
   RTC_DISALLOW_COPY_AND_ASSIGN(CapturedFrame);
 };
 
 // VideoCapturer is an abstract class that defines the interfaces for video
 // capturing. The subclasses implement the video capturer for various types of
 // capturers and various platforms.
 //
 // The captured frames may need to be adapted (for example, cropping).
 // Video adaptation is built into and enabled by default. After a frame has
 // been captured from the device, it is sent to the video adapter, then out to
-// the sinks.
+// the encoder.
 //
 // Programming model:
 //   Create an object of a subclass of VideoCapturer
 //   Initialize
 //   SignalStateChange.connect()
-//   AddOrUpdateSink()
+//   SignalFrameCaptured.connect()
 //   Find the capture format for Start() by either calling GetSupportedFormats()
 //   and selecting one of the supported or calling GetBestCaptureFormat().
 //   video_adapter()->OnOutputFormatRequest(desired_encoding_format)
 //   Start()
 //   GetCaptureFormat() optionally
 //   Stop()
 //
 // Assumption:
 //   The Start() and Stop() methods are called by a single thread (E.g., the
 //   media engine thread). Hence, the VideoCapture subclasses dont need to be
 //   thread safe.
 //
 class VideoCapturer : public sigslot::has_slots<>,
+                      public rtc::MessageHandler,
                       public rtc::VideoSourceInterface<cricket::VideoFrame> {
  public:
+  // All signals are marshalled to |thread| or the creating thread if
+  // none is provided.
   VideoCapturer();
-
+  explicit VideoCapturer(rtc::Thread* thread);
   virtual ~VideoCapturer() {}
 
   // Gets the id of the underlying device, which is available after the capturer
   // is initialized. Can be used to determine if two capturers reference the
   // same device.
   const std::string& GetId() const { return id_; }
 
   // Get the capture formats supported by the video capturer. The supported
   // formats are non empty after the device has been opened successfully.
   const std::vector<VideoFormat>* GetSupportedFormats() const;
@@ skipping 25 matching lines @@
   //                   GetSupportedFormats() and selecting one of the supported
   //                   or calling GetBestCaptureFormat().
   // Return
   //   CS_STARTING:  The capturer is trying to start. Success or failure will
   //                 be notified via the |SignalStateChange| callback.
   //   CS_RUNNING:   if the capturer is started and capturing.
   //   CS_PAUSED:    Will never be returned.
   //   CS_FAILED:    if the capturer failes to start..
   //   CS_NO_DEVICE: if the capturer has no device and fails to start.
   virtual CaptureState Start(const VideoFormat& capture_format) = 0;
+  // Sets the desired aspect ratio. If the capturer is capturing at another
+  // aspect ratio it will crop the width or the height so that asked for
+  // aspect ratio is acheived. Note that ratio_w and ratio_h do not need to be
+  // relatively prime.
+  void UpdateAspectRatio(int ratio_w, int ratio_h);
+  void ClearAspectRatio();
 
   // Get the current capture format, which is set by the Start() call.
   // Note that the width and height of the captured frames may differ from the
   // capture format. For example, the capture format is HD but the captured
   // frames may be smaller than HD.
   const VideoFormat* GetCaptureFormat() const {
     return capture_format_.get();
   }
 
+  // Pause the video capturer.
+  virtual bool Pause(bool paused);
   // Stop the video capturer.
   virtual void Stop() = 0;
   // Check if the video capturer is running.
   virtual bool IsRunning() = 0;
+  // Restart the video capturer with the new |capture_format|.
+  // Default implementation stops and starts the capturer.
+  virtual bool Restart(const VideoFormat& capture_format);
+  // TODO(thorcarpenter): This behavior of keeping the camera open just to emit
+  // black frames is a total hack and should be fixed.
+  // When muting, produce black frames then pause the camera.
+  // When unmuting, start the camera. Camera starts unmuted.
+  virtual bool MuteToBlackThenPause(bool muted);
+  virtual bool IsMuted() const {
+    return muted_;
+  }
   CaptureState capture_state() const {
     return capture_state_;
   }
 
   virtual bool GetApplyRotation() { return apply_rotation_; }
 
   // Returns true if the capturer is screencasting. This can be used to
   // implement screencast specific behavior.
   virtual bool IsScreencast() const = 0;
 
   // Caps the VideoCapturer's format according to max_format. It can e.g. be
   // used to prevent cameras from capturing at a resolution or framerate that
   // the capturer is capable of but not performing satisfactorily at.
   // The capping is an upper bound for each component of the capturing format.
   // The fourcc component is ignored.
   void ConstrainSupportedFormats(const VideoFormat& max_format);
 
   void set_enable_camera_list(bool enable_camera_list) {
     enable_camera_list_ = enable_camera_list;
   }
   bool enable_camera_list() {
     return enable_camera_list_;
   }
 
+  // Enable scaling to ensure square pixels.
+  void set_square_pixel_aspect_ratio(bool square_pixel_aspect_ratio) {
+    square_pixel_aspect_ratio_ = square_pixel_aspect_ratio;
+  }
+  bool square_pixel_aspect_ratio() {
+    return square_pixel_aspect_ratio_;
+  }
+
   // Signal all capture state changes that are not a direct result of calling
   // Start().
   sigslot::signal2<VideoCapturer*, CaptureState> SignalStateChange;
   // Frame callbacks are multithreaded to allow disconnect and connect to be
   // called concurrently. It also ensures that it is safe to call disconnect
   // at any time which is needed since the signal may be called from an
   // unmarshalled thread owned by the VideoCapturer.
   // Signal the captured frame to downstream.
   sigslot::signal2<VideoCapturer*, const CapturedFrame*,
                    sigslot::multi_threaded_local> SignalFrameCaptured;
@@ skipping 41 matching lines @@
   // Callback attached to SignalFrameCaptured where SignalVideoFrames is called.
   void OnFrameCaptured(VideoCapturer* video_capturer,
                        const CapturedFrame* captured_frame);
 
   // Callback attached to SignalVideoFrame.
   // TODO(perkj): Remove once SignalVideoFrame is removed.
   void OnFrame(VideoCapturer* capturer, const VideoFrame* frame);
 
   void SetCaptureState(CaptureState state);
 
+  // Marshals SignalStateChange onto thread_.
+  void OnMessage(rtc::Message* message) override;
+
   // subclasses override this virtual method to provide a vector of fourccs, in
   // order of preference, that are expected by the media engine.
   virtual bool GetPreferredFourccs(std::vector<uint32_t>* fourccs) = 0;
 
   // mutators to set private attributes
   void SetId(const std::string& id) {
     id_ = id;
   }
 
   void SetCaptureFormat(const VideoFormat* format) {
@@ skipping 28 matching lines @@
 
   void UpdateStats(const CapturedFrame* captured_frame);
 
   // Helper function to save statistics on the current data from a
   // RollingAccumulator into stats.
   template<class T>
   static void GetVariableSnapshot(
       const rtc::RollingAccumulator<T>& data,
       VariableInfo<T>* stats);
 
-  rtc::ThreadChecker thread_checker_;
+  rtc::Thread* thread_;
   std::string id_;
   CaptureState capture_state_;
   rtc::scoped_ptr<VideoFrameFactory> frame_factory_;
   rtc::scoped_ptr<VideoFormat> capture_format_;
   std::vector<VideoFormat> supported_formats_;
   rtc::scoped_ptr<VideoFormat> max_format_;
   std::vector<VideoFormat> filtered_supported_formats_;
 
   int ratio_w_;  // View resolution. e.g. 1280 x 720.
   int ratio_h_;
   bool enable_camera_list_;
   bool square_pixel_aspect_ratio_;  // Enable scaling to square pixels.
   int scaled_width_;  // Current output size from ComputeScale.
   int scaled_height_;
+  bool muted_;
+  int black_frame_count_down_;
 
   rtc::VideoBroadcaster broadcaster_;
   bool enable_video_adapter_;
   CoordinatedVideoAdapter video_adapter_;
 
   rtc::Timing frame_length_time_reporter_;
   rtc::CriticalSection frame_stats_crit_;
 
   int adapt_frame_drops_;
   rtc::RollingAccumulator<int> adapt_frame_drops_data_;
   double previous_frame_time_;
   rtc::RollingAccumulator<double> frame_time_data_;
   // The captured frame format before potential adapation.
   VideoFormat last_captured_frame_format_;
 
   // Whether capturer should apply rotation to the frame before signaling it.
   bool apply_rotation_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOCAPTURER_H_