Move direct use of VideoCapturer::VideoAdapter to VideoSinkWants.

webrtc/media/base/videoadapter.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.
  */
 
 #include "webrtc/media/base/videoadapter.h"
 
 #include <limits.h>  // For INT_MAX
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/constants.h"
 #include "webrtc/media/base/videocommon.h"
 #include "webrtc/media/base/videoframe.h"
 
 namespace cricket {
 
-// TODO(fbarchard): Make downgrades settable
-static const int kMaxCpuDowngrades = 2;  // Downgrade at most 2 times for CPU.
-// The number of cpu samples to require before adapting. This value depends on
-// the cpu monitor sampling frequency being 2000ms.
-static const int kCpuLoadMinSamples = 3;
-// The amount of weight to give to each new cpu load sample. The lower the
-// value, the slower we'll adapt to changing cpu conditions.
-static const float kCpuLoadWeightCoefficient = 0.4f;
-// The seed value for the cpu load moving average.
-static const float kCpuLoadInitialAverage = 0.5f;
-
 // Desktop needs 1/8 scale for HD (1280 x 720) to QQVGA (160 x 90)
 static const float kScaleFactors[] = {
   1.f / 1.f,   // Full size.
   3.f / 4.f,   // 3/4 scale.
   1.f / 2.f,   // 1/2 scale.
   3.f / 8.f,   // 3/8 scale.
   1.f / 4.f,   // 1/4 scale.
   3.f / 16.f,  // 3/16 scale.
   1.f / 8.f,   // 1/8 scale.
   0.f  // End of table.
@@ skipping 146 matching lines @@
     LOG(LS_INFO) << "VAdapt Input Resolution Change: "
                  << "Previous input resolution: "
                  << previous_width << "x" << previous_height
                  << " New input resolution: "
                  << format.width << "x" << format.height
                  << " New output resolution: "
                  << width << "x" << height;
   }
 }
 
-void CoordinatedVideoAdapter::set_cpu_smoothing(bool enable) {
-  LOG(LS_INFO) << "CPU smoothing is now "
-               << (enable ? "enabled" : "disabled");
-  cpu_smoothing_ = enable;
-}
-
 void VideoAdapter::SetOutputFormat(const VideoFormat& format) {
   rtc::CritScope cs(&critical_section_);
   int64_t old_output_interval = output_format_.interval;
   output_format_ = format;
   output_num_pixels_ = output_format_.width * output_format_.height;
   output_format_.interval =
       std::max(output_format_.interval, input_format_.interval);
   if (old_output_interval != output_format_.interval) {
     LOG(LS_INFO) << "VAdapt output interval changed from "
       << old_output_interval << " to " << output_format_.interval;
@@ skipping 122 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////
 // Implementation of CoordinatedVideoAdapter
 CoordinatedVideoAdapter::CoordinatedVideoAdapter()
     : cpu_adaptation_(true),
       cpu_smoothing_(false),
       gd_adaptation_(true),
       view_adaptation_(true),
       view_switch_(false),
-      cpu_downgrade_count_(0),
-      cpu_load_min_samples_(kCpuLoadMinSamples),
-      cpu_load_num_samples_(0),
-      high_system_threshold_(kHighSystemCpuThreshold),
-      low_system_threshold_(kLowSystemCpuThreshold),
-      process_threshold_(kProcessCpuThreshold),
       view_desired_num_pixels_(INT_MAX),
       view_desired_interval_(0),
       encoder_desired_num_pixels_(INT_MAX),
       cpu_desired_num_pixels_(INT_MAX),
-      adapt_reason_(ADAPTREASON_NONE),
-      system_load_average_(kCpuLoadInitialAverage) {
-}
+      adapt_reason_(ADAPTREASON_NONE) {}
 
 // Helper function to UPGRADE or DOWNGRADE a number of pixels
 void CoordinatedVideoAdapter::StepPixelCount(
     CoordinatedVideoAdapter::AdaptRequest request,
     int* num_pixels) {
   switch (request) {
     case CoordinatedVideoAdapter::DOWNGRADE:
       *num_pixels /= 2;
       break;
 
     case CoordinatedVideoAdapter::UPGRADE:
       *num_pixels *= 2;
       break;
 
     default:  // No change in pixel count
       break;
   }
   return;
 }
 
-// Find the adaptation request of the cpu based on the load. Return UPGRADE if
-// the load is low, DOWNGRADE if the load is high, and KEEP otherwise.
-CoordinatedVideoAdapter::AdaptRequest CoordinatedVideoAdapter::FindCpuRequest(
-    int current_cpus, int max_cpus,
-    float process_load, float system_load) {
-  // Downgrade if system is high and plugin is at least more than midrange.
-  if (system_load >= high_system_threshold_ * max_cpus &&
-      process_load >= process_threshold_ * current_cpus) {
-    return CoordinatedVideoAdapter::DOWNGRADE;
-  // Upgrade if system is low.
-  } else if (system_load < low_system_threshold_ * max_cpus) {
-    return CoordinatedVideoAdapter::UPGRADE;
-  }
-  return CoordinatedVideoAdapter::KEEP;
-}
 
 // A remote view request for a new resolution.
 void CoordinatedVideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
   rtc::CritScope cs(&request_critical_section_);
   if (!view_adaptation_) {
     return;
   }
   // Set output for initial aspect ratio in mediachannel unittests.
   int old_num_pixels = GetOutputNumPixels();
   SetOutputFormat(format);
   SetOutputNumPixels(old_num_pixels);
   view_desired_num_pixels_ = format.width * format.height;
   view_desired_interval_ = format.interval;
   int new_width, new_height;
   bool changed = AdaptToMinimumFormat(&new_width, &new_height);
   LOG(LS_INFO) << "VAdapt View Request: "
                << format.width << "x" << format.height
                << " Pixels: " << view_desired_num_pixels_
                << " Changed: " << (changed ? "true" : "false")
                << " To: " << new_width << "x" << new_height;
 }
 
-void CoordinatedVideoAdapter::set_cpu_load_min_samples(
-    int cpu_load_min_samples) {
-  if (cpu_load_min_samples_ != cpu_load_min_samples) {
-    LOG(LS_INFO) << "VAdapt Change Cpu Adapt Min Samples from: "
-                 << cpu_load_min_samples_ << " to "
-                 << cpu_load_min_samples;
-    cpu_load_min_samples_ = cpu_load_min_samples;
-  }
-}
-
-void CoordinatedVideoAdapter::set_high_system_threshold(
-    float high_system_threshold) {
-  ASSERT(high_system_threshold <= 1.0f);
-  ASSERT(high_system_threshold >= 0.0f);
-  if (high_system_threshold_ != high_system_threshold) {
-    LOG(LS_INFO) << "VAdapt Change High System Threshold from: "
-                 << high_system_threshold_ << " to " << high_system_threshold;
-    high_system_threshold_ = high_system_threshold;
-  }
-}
-
-void CoordinatedVideoAdapter::set_low_system_threshold(
-    float low_system_threshold) {
-  ASSERT(low_system_threshold <= 1.0f);
-  ASSERT(low_system_threshold >= 0.0f);
-  if (low_system_threshold_ != low_system_threshold) {
-    LOG(LS_INFO) << "VAdapt Change Low System Threshold from: "
-                 << low_system_threshold_ << " to " << low_system_threshold;
-    low_system_threshold_ = low_system_threshold;
-  }
-}
-
-void CoordinatedVideoAdapter::set_process_threshold(float process_threshold) {
-  ASSERT(process_threshold <= 1.0f);
-  ASSERT(process_threshold >= 0.0f);
-  if (process_threshold_ != process_threshold) {
-    LOG(LS_INFO) << "VAdapt Change High Process Threshold from: "
-                 << process_threshold_ << " to " << process_threshold;
-    process_threshold_ = process_threshold;
-  }
-}
-
 // A Bandwidth GD request for new resolution
 void CoordinatedVideoAdapter::OnEncoderResolutionRequest(
     int width, int height, AdaptRequest request) {
   rtc::CritScope cs(&request_critical_section_);
   if (!gd_adaptation_) {
     return;
   }
   int old_encoder_desired_num_pixels = encoder_desired_num_pixels_;
   if (KEEP != request) {
     int new_encoder_desired_num_pixels = width * height;
@@ skipping 17 matching lines @@
 
   LOG(LS_INFO) << "VAdapt GD Request: "
                << (DOWNGRADE == request ? "down" :
                    (UPGRADE == request ? "up" : "keep"))
                << " From: " << width << "x" << height
                << " Pixels: " << encoder_desired_num_pixels_
                << " Changed: " << (changed ? "true" : "false")
                << " To: " << new_width << "x" << new_height;
 }
 
-// A Bandwidth GD request for new resolution
-void CoordinatedVideoAdapter::OnCpuResolutionRequest(AdaptRequest request) {
+void CoordinatedVideoAdapter::OnLimitResolution(int max_number_of_pixels) {
   rtc::CritScope cs(&request_critical_section_);
   if (!cpu_adaptation_) {
     return;
   }
-  // Update how many times we have downgraded due to the cpu load.
-  switch (request) {
-    case DOWNGRADE:
-      // Ignore downgrades if we have downgraded the maximum times.
-      if (cpu_downgrade_count_ < kMaxCpuDowngrades) {
-        ++cpu_downgrade_count_;
-      } else {
-        LOG(LS_VERBOSE) << "VAdapt CPU load high but do not downgrade "
-                           "because maximum downgrades reached";
-        SignalCpuAdaptationUnable();
-      }
-      break;
-    case UPGRADE:
-      if (cpu_downgrade_count_ > 0) {
-        bool is_min = IsMinimumFormat(cpu_desired_num_pixels_);
-        if (is_min) {
-          --cpu_downgrade_count_;
-        } else {
-          LOG(LS_VERBOSE) << "VAdapt CPU load low but do not upgrade "
-                             "because cpu is not limiting resolution";
-        }
-      } else {
-        LOG(LS_VERBOSE) << "VAdapt CPU load low but do not upgrade "
-                           "because minimum downgrades reached";
-      }
-      break;
-    case KEEP:
-    default:
-      break;
+
+  const VideoFormat& input = input_format();
+  if (input.IsSize0x0()) {
+    // TODO NOW.... Make sure AdaptToMinimumFormat can be called before first
+    // frame....
+    return;
   }
-  if (KEEP != request) {
-    // TODO(fbarchard): compute stepping up/down from OutputNumPixels but
-    // clamp to inputpixels / 4 (2 steps)
-    cpu_desired_num_pixels_ =  cpu_downgrade_count_ == 0 ? INT_MAX :
-        static_cast<int>(input_format().width * input_format().height >>
-                         cpu_downgrade_count_);
-  }
+  cpu_desired_num_pixels_ =
+      std::min(input.width * input.height, max_number_of_pixels);
+
   int new_width, new_height;
   bool changed = AdaptToMinimumFormat(&new_width, &new_height);
-  LOG(LS_INFO) << "VAdapt CPU Request: "
-               << (DOWNGRADE == request ? "down" :
-                   (UPGRADE == request ? "up" : "keep"))
-               << " Steps: " << cpu_downgrade_count_
+  LOG(LS_INFO) << "VAdapt OnLimitResolution: "
                << " Changed: " << (changed ? "true" : "false")
                << " To: " << new_width << "x" << new_height;
 }
 
-// A CPU request for new resolution
-// TODO(fbarchard): Move outside adapter.
-void CoordinatedVideoAdapter::OnCpuLoadUpdated(
-    int current_cpus, int max_cpus, float process_load, float system_load) {
-  rtc::CritScope cs(&request_critical_section_);
-  if (!cpu_adaptation_) {
-    return;
-  }
-  // Update the moving average of system load. Even if we aren't smoothing,
-  // we'll still calculate this information, in case smoothing is later enabled.
-  system_load_average_ = kCpuLoadWeightCoefficient * system_load +
-      (1.0f - kCpuLoadWeightCoefficient) * system_load_average_;
-  ++cpu_load_num_samples_;
-  if (cpu_smoothing_) {
-    system_load = system_load_average_;
-  }
-  AdaptRequest request = FindCpuRequest(current_cpus, max_cpus,
-                                        process_load, system_load);
-  // Make sure we're not adapting too quickly.
-  if (request != KEEP) {
-    if (cpu_load_num_samples_ < cpu_load_min_samples_) {
-      LOG(LS_VERBOSE) << "VAdapt CPU load high/low but do not adapt until "
-                      << (cpu_load_min_samples_ - cpu_load_num_samples_)
-                      << " more samples";
-      request = KEEP;
-    }
-  }
-
-  OnCpuResolutionRequest(request);
-}
-
 // Called by cpu adapter on up requests.
 bool CoordinatedVideoAdapter::IsMinimumFormat(int pixels) {
   // Find closest scale factor that matches input resolution to min_num_pixels
   // and set that for output resolution.  This is not needed for VideoAdapter,
   // but provides feedback to unittests and users on expected resolution.
   // Actual resolution is based on input frame.
   VideoFormat new_output = output_format();
   VideoFormat input = input_format();
   if (input_format().IsSize0x0()) {
     input = new_output;
@@ skipping 90 matching lines @@
                   << " CPU: " << cpu_desired_num_pixels_
                   << " Pixels: " << min_num_pixels
                   << " Input: " << input.width
                   << "x" << input.height
                   << " Scale: " << scale
                   << " Resolution: " << new_output.width
                   << "x" << new_output.height
                   << " Changed: " << (changed ? "true" : "false")
                   << " Reason: " << kReasons[adapt_reason_];
 
-  if (changed) {
-    // When any adaptation occurs, historic CPU load levels are no longer
-    // accurate. Clear out our state so we can re-learn at the new normal.
-    cpu_load_num_samples_ = 0;
-    system_load_average_ = kCpuLoadInitialAverage;
-  }
-
   return changed;
 }
 
 }  // namespace cricket