Revert of Make cricket::VideoCapturer implement VideoSourceInterface

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/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.
@@ skipping 26 matching lines @@
   // fourcc, pixel_width, and pixel_height should keep the same over frames.
   int width;              // in number of pixels
   int height;             // in number of pixels
   uint32_t fourcc;        // compression
   uint32_t pixel_width;   // width of a pixel, default is 1
   uint32_t pixel_height;  // height of a pixel, default is 1
   int64_t time_stamp;  // timestamp of when the frame was captured, in unix
                        // time with nanosecond units.
   uint32_t data_size;  // number of bytes of the frame data
 
-  webrtc::VideoRotation rotation;  // rotation in degrees of the frame.
+  webrtc::VideoRotation rotation; // rotation in degrees of the frame.
 
   void*  data;          // pointer to the frame data. This object allocates the
                         // memory or points to an existing memory.
 
  private:
   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
@@ skipping 14 matching lines @@
 //   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> {
+class VideoCapturer
+    : public sigslot::has_slots<>,
+      public rtc::MessageHandler {
  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.
@@ skipping 66 matching lines @@
   // 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_;
   }
 
+  // Tells videocapturer whether to apply the pending rotation. By default, the
+  // rotation is applied and the generated frame is up right. When set to false,
+  // generated frames will carry the rotation information from
+  // SetCaptureRotation. Return value indicates whether this operation succeeds.
+  virtual bool SetApplyRotation(bool enable);
   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.
@@ skipping 18 matching lines @@
   // 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;
+  // Signal the captured and possibly adapted frame to downstream consumers
+  // such as the encoder.
+  sigslot::signal2<VideoCapturer*, const VideoFrame*,
+                   sigslot::multi_threaded_local> SignalVideoFrame;
 
   // If true, run video adaptation. By default, video adaptation is enabled
   // and users must call video_adapter()->OnOutputFormatRequest()
   // to receive frames.
   bool enable_video_adapter() const { return enable_video_adapter_; }
   void set_enable_video_adapter(bool enable_video_adapter) {
     enable_video_adapter_ = enable_video_adapter;
   }
 
   CoordinatedVideoAdapter* video_adapter() { return &video_adapter_; }
   const CoordinatedVideoAdapter* video_adapter() const {
     return &video_adapter_;
   }
 
   // Takes ownership.
   void set_frame_factory(VideoFrameFactory* frame_factory);
 
   // Gets statistics for tracked variables recorded since the last call to
   // GetStats.  Note that calling GetStats resets any gathered data so it
   // should be called only periodically to log statistics.
   void GetStats(VariableInfo<int>* adapt_drop_stats,
                 VariableInfo<int>* effect_drop_stats,
                 VariableInfo<double>* frame_time_stats,
                 VideoFormat* last_captured_frame_format);
 
-  // Implements VideoSourceInterface
-  void AddOrUpdateSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
-                       const rtc::VideoSinkWants& wants) override;
-  void RemoveSink(rtc::VideoSinkInterface<cricket::VideoFrame>* sink) override;
-
  protected:
-  // OnSinkWantsChanged can be overridden to change the default behavior
-  // when a sink changes its VideoSinkWants by calling AddOrUpdateSink.
-  virtual void OnSinkWantsChanged(const rtc::VideoSinkWants& wants);
-
   // Callback attached to SignalFrameCaptured where SignalVideoFrames is called.
   void OnFrameCaptured(VideoCapturer* video_capturer,
                        const CapturedFrame* captured_frame);
   void SetCaptureState(CaptureState state);
 
   // Marshals SignalStateChange onto thread_.
   void OnMessage(rtc::Message* message);
 
   // subclasses override this virtual method to provide a vector of fourccs, in
   // order of preference, that are expected by the media engine.
@@ skipping 54 matching lines @@
 
   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_