Remove cricket::VideoProcessor and AddVideoProcessor() functionality

talk/media/base/videocapturer.h

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 33 matching lines @@
 #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"
 
 
 namespace cricket {
 
-class VideoProcessor;
-
 // 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.
@@ skipping 42 matching lines @@
  private:
   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 video
-// processors, then out to the encoder.
+// been captured from the device, it is sent to the video adapter, then out to
+// the encoder.
 //
 // Programming model:
 //   Create an object of a subclass of VideoCapturer
 //   Initialize
 //   SignalStateChange.connect()
 //   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:
-  typedef std::vector<VideoProcessor*> VideoProcessors;
-
   // 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_; }
@@ skipping 72 matching lines @@
     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_; }
 
-  // Adds a video processor that will be applied on VideoFrames returned by
-  // |SignalVideoFrame|. Multiple video processors can be added. The video
-  // processors will be applied in the order they were added.
-  void AddVideoProcessor(VideoProcessor* video_processor);
-  // Removes the |video_processor| from the list of video processors or
-  // returns false.
-  bool RemoveVideoProcessor(VideoProcessor* video_processor);
-
   // 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);
@@ skipping 21 matching lines @@
   // 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;
 
-  const VideoProcessors& video_processors() const { return video_processors_; }
-
   // If 'screencast_max_pixels' is set greater than zero, screencasts will be
   // scaled to be no larger than this value.
   // If set to zero, the max pixels will be limited to
   // Retina MacBookPro 15" resolution of 2880 x 1800.
   // For high fps, maximum pixels limit is set based on common 24" monitor
   // resolution of 2048 x 1280.
   int screencast_max_pixels() const { return screencast_max_pixels_; }
   void set_screencast_max_pixels(int p) {
     screencast_max_pixels_ = std::max(0, p);
   }
@@ skipping 57 matching lines @@
   void Construct();
   // Get the distance between the desired format and the supported format.
   // Return the max distance if they mismatch. See the implementation for
   // details.
   int64 GetFormatDistance(const VideoFormat& desired,
                           const VideoFormat& supported);
 
   // Convert captured frame to readable string for LOG messages.
   std::string ToString(const CapturedFrame* frame) const;
 
-  // Applies all registered processors. If any of the processors signal that
-  // the frame should be dropped the return value will be false. Note that
-  // this frame should be dropped as it has not applied all processors.
-  bool ApplyProcessors(VideoFrame* video_frame);
-
   // Updates filtered_supported_formats_ so that it contains the formats in
   // supported_formats_ that fulfill all applied restrictions.
   void UpdateFilteredSupportedFormats();
   // Returns true if format doesn't fulfill all applied restrictions.
   bool ShouldFilterFormat(const VideoFormat& format) const;
 
   void UpdateStats(const CapturedFrame* captured_frame);
 
   // Helper function to save statistics on the current data from a
   // RollingAccumulator into stats.
@@ skipping 22 matching lines @@
   int black_frame_count_down_;
 
   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_;
-  int effect_frame_drops_;
-  rtc::RollingAccumulator<int> effect_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_;
 
-  rtc::CriticalSection crit_;
-  VideoProcessors video_processors_;
-
   // Whether capturer should apply rotation to the frame before signaling it.
   bool apply_rotation_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCapturer);
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_VIDEOCAPTURER_H_