Remove cricket::VideoProcessor and AddVideoProcessor() functionality

talk/media/base/videocapturer.cc

 /*
  * 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 15 matching lines @@
  */
 
 // Implementation file of class VideoCapturer.
 
 #include "talk/media/base/videocapturer.h"
 
 #include <algorithm>
 
 #include "libyuv/scale_argb.h"
 #include "talk/media/base/videoframefactory.h"
-#include "talk/media/base/videoprocessor.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/systeminfo.h"
 
 #if defined(HAVE_WEBRTC_VIDEO)
 #include "talk/media/webrtc/webrtcvideoframe.h"
 #include "talk/media/webrtc/webrtcvideoframefactory.h"
 #endif  // HAVE_WEBRTC_VIDEO
 
 namespace cricket {
@@ skipping 53 matching lines @@
   ASSERT(rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270);
   return static_cast<webrtc::VideoRotation>(rotation);
 }
 
 /////////////////////////////////////////////////////////////////////
 // Implementation of class VideoCapturer
 /////////////////////////////////////////////////////////////////////
 VideoCapturer::VideoCapturer()
     : thread_(rtc::Thread::Current()),
       adapt_frame_drops_data_(kMaxAccumulatorSize),
-      effect_frame_drops_data_(kMaxAccumulatorSize),
       frame_time_data_(kMaxAccumulatorSize),
       apply_rotation_(true) {
   Construct();
 }
 
 VideoCapturer::VideoCapturer(rtc::Thread* thread)
     : thread_(thread),
       adapt_frame_drops_data_(kMaxAccumulatorSize),
-      effect_frame_drops_data_(kMaxAccumulatorSize),
       frame_time_data_(kMaxAccumulatorSize),
       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);
   scaled_width_ = 0;
   scaled_height_ = 0;
   screencast_max_pixels_ = 0;
   muted_ = false;
   black_frame_count_down_ = kNumBlackFramesOnMute;
   enable_video_adapter_ = true;
   adapt_frame_drops_ = 0;
-  effect_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
 }
@@ skipping 153 matching lines @@
     best_format->width = best->width;
     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::AddVideoProcessor(VideoProcessor* video_processor) {
-  rtc::CritScope cs(&crit_);
-  ASSERT(std::find(video_processors_.begin(), video_processors_.end(),
-                   video_processor) == video_processors_.end());
-  video_processors_.push_back(video_processor);
-}
-
-bool VideoCapturer::RemoveVideoProcessor(VideoProcessor* video_processor) {
-  rtc::CritScope cs(&crit_);
-  VideoProcessors::iterator found = std::find(
-      video_processors_.begin(), video_processors_.end(), video_processor);
-  if (found == video_processors_.end()) {
-    return false;
-  }
-  video_processors_.erase(found);
-  return true;
-}
-
 void VideoCapturer::ConstrainSupportedFormats(const VideoFormat& max_format) {
   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) {
@@ skipping 16 matching lines @@
     frame_factory->SetApplyRotation(apply_rotation_);
   }
 }
 
 void VideoCapturer::GetStats(VariableInfo<int>* adapt_drops_stats,
                              VariableInfo<int>* effect_drops_stats,
                              VariableInfo<double>* frame_time_stats,
                              VideoFormat* last_captured_frame_format) {
   rtc::CritScope cs(&frame_stats_crit_);
   GetVariableSnapshot(adapt_frame_drops_data_, adapt_drops_stats);
-  GetVariableSnapshot(effect_frame_drops_data_, effect_drops_stats);
   GetVariableSnapshot(frame_time_data_, frame_time_stats);
   *last_captured_frame_format = last_captured_frame_format_;
 
   adapt_frame_drops_data_.Reset();
-  effect_frame_drops_data_.Reset();
   frame_time_data_.Reset();
 }
 
 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_;
@@ skipping 178 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_ && !ApplyProcessors(adapted_frame.get())) {
-    // Processor dropped the frame.
-    ++effect_frame_drops_;
-    return;
-  }
   if (muted_) {
     // TODO(pthatcher): Use frame_factory_->CreateBlackFrame() instead.
     adapted_frame->SetToBlack();
   }
   SignalVideoFrame(this, adapted_frame.get());
 
   UpdateStats(captured_frame);
 }
 
 void VideoCapturer::SetCaptureState(CaptureState state) {
@@ skipping 117 matching lines @@
   }
   int64 idelta_fps = static_cast<int>(delta_fps);
 
   // 12 bits for width and height and 8 bits for fps and fourcc.
   distance |=
       (delta_w << 28) | (delta_h << 16) | (idelta_fps << 8) | delta_fourcc;
 
   return distance;
 }
 
-bool VideoCapturer::ApplyProcessors(VideoFrame* video_frame) {
-  bool drop_frame = false;
-  rtc::CritScope cs(&crit_);
-  for (VideoProcessors::iterator iter = video_processors_.begin();
-       iter != video_processors_.end(); ++iter) {
-    (*iter)->OnFrame(kDummyVideoSsrc, video_frame, &drop_frame);
-    if (drop_frame) {
-      return false;
-    }
-  }
-  return true;
-}
-
 void VideoCapturer::UpdateFilteredSupportedFormats() {
   filtered_supported_formats_.clear();
   filtered_supported_formats_ = supported_formats_;
   if (!max_format_) {
     return;
   }
   std::vector<VideoFormat>::iterator iter = filtered_supported_formats_.begin();
   while (iter != filtered_supported_formats_.end()) {
     if (ShouldFilterFormat(*iter)) {
       iter = filtered_supported_formats_.erase(iter);
@@ skipping 23 matching lines @@
 
   last_captured_frame_format_.width = captured_frame->width;
   last_captured_frame_format_.height = captured_frame->height;
   // TODO(ronghuawu): Useful to report interval as well?
   last_captured_frame_format_.interval = 0;
   last_captured_frame_format_.fourcc = captured_frame->fourcc;
 
   double time_now = frame_length_time_reporter_.TimerNow();
   if (previous_frame_time_ != 0.0) {
     adapt_frame_drops_data_.AddSample(adapt_frame_drops_);
-    effect_frame_drops_data_.AddSample(effect_frame_drops_);
     frame_time_data_.AddSample(time_now - previous_frame_time_);
   }
   previous_frame_time_ = time_now;
-  effect_frame_drops_ = 0;
   adapt_frame_drops_ = 0;
 }
 
 template<class T>
 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