Cleanup the VideoAdapter

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 <limits>
 
 #include "webrtc/base/logging.h"
-#include "webrtc/base/timeutils.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/videocommon.h"
-#include "webrtc/media/base/videoframe.h"
 
-namespace cricket {
+namespace {
 
-// 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.
+// Scale factors optimized for in libYUV that we accept.
+// Must be sorted in decreasing scale factors for FindScaleLargerThan to work.
+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.
 };
 
-// TODO(fbarchard): Use this table (optionally) for CPU and GD as well.
-static const float kViewScaleFactors[] = {
-  1.f / 1.f,   // Full size.
-  3.f / 4.f,   // 3/4 scale.
-  2.f / 3.f,   // 2/3 scale.  // Allow 1080p to 720p.
-  1.f / 2.f,   // 1/2 scale.
-  3.f / 8.f,   // 3/8 scale.
-  1.f / 3.f,   // 1/3 scale.  // Allow 1080p to 360p.
-  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.
-};
-
-const float* VideoAdapter::GetViewScaleFactors() const {
-  return scale_third_ ? kViewScaleFactors : kScaleFactors;
-}
-
-// For resolutions that would scale down a little instead of up a little,
-// bias toward scaling up a little.  This will tend to choose 3/4 scale instead
-// of 2/3 scale, when the 2/3 is not an exact match.
-static const float kUpBias = -0.9f;
-// Find the scale factor that, when applied to width and height, is closest
-// to num_pixels.
-float VideoAdapter::FindScale(const float* scale_factors,
-                              const float upbias,
-                              int width, int height,
-                              int target_num_pixels) {
-  const float kMinNumPixels = 160 * 90;
-  if (!target_num_pixels) {
-    return 0.f;
-  }
-  float best_distance = static_cast<float>(INT_MAX);
-  float best_scale = 1.f;  // Default to unscaled if nothing matches.
-  float pixels = static_cast<float>(width * height);
-  for (int i = 0; ; ++i) {
-    float scale = scale_factors[i];
+float FindScaleLessThanOrEqual(int width,
+                               int height,
+                               int target_num_pixels,
+                               int* resulting_number_of_pixels) {
+  float best_distance = std::numeric_limits<float>::max();
+  float best_scale = 0.0f;  // Default to 0 if nothing matches.
+  float pixels = width * height;
+  float best_number_of_pixels = 0.0f;
+  for (const auto& scale : kScaleFactors) {
     float test_num_pixels = pixels * scale * scale;
-    // Do not consider scale factors that produce too small images.
-    // Scale factor of 0 at end of table will also exit here.
-    if (test_num_pixels < kMinNumPixels) {
-      break;
-    }
     float diff = target_num_pixels - test_num_pixels;
-    // If resolution is higher than desired, bias the difference based on
-    // preference for slightly larger for nearest, or avoid completely if
-    // looking for lower resolutions only.
     if (diff < 0) {
-      diff = diff * kUpBias;
+      continue;
     }
     if (diff < best_distance) {
       best_distance = diff;
       best_scale = scale;
+      best_number_of_pixels = test_num_pixels;
       if (best_distance == 0) {  // Found exact match.
         break;
       }
     }
   }
+  if (resulting_number_of_pixels) {
+    *resulting_number_of_pixels = static_cast<int>(best_number_of_pixels + .5f);
+  }
   return best_scale;
 }
 
-// Find the closest scale factor.
-float VideoAdapter::FindClosestScale(int width, int height,
-                                         int target_num_pixels) {
-  return FindScale(kScaleFactors, kUpBias,
-                   width, height, target_num_pixels);
+float FindScaleLargerThan(int width,
+                          int height,
+                          int target_num_pixels,
+                          int* resulting_number_of_pixels) {
+  float best_distance = std::numeric_limits<float>::max();
+  float best_scale = 1.f;  // Default to unscaled if nothing matches.
+  float pixels = width * height;
+  float best_number_of_pixels = pixels;  // Default to input number of pixels.
+  for (const auto& scale : kScaleFactors) {
+    float test_num_pixels = pixels * scale * scale;
+    float diff = test_num_pixels - target_num_pixels;
+    if (diff <= 0) {
+      break;
+    }
+    if (diff < best_distance) {
+      best_distance = diff;
+      best_scale = scale;
+      best_number_of_pixels = test_num_pixels;
+    }
+  }
+
+  *resulting_number_of_pixels = static_cast<int>(best_number_of_pixels + .5f);
+  return best_scale;
 }
 
-// Find the closest view scale factor.
-float VideoAdapter::FindClosestViewScale(int width, int height,
-                                         int target_num_pixels) {
-  return FindScale(GetViewScaleFactors(), kUpBias,
-                   width, height, target_num_pixels);
-}
+}  // namespace
 
-// Finds the scale factor that, when applied to width and height, produces
-// fewer than num_pixels.
-static const float kUpAvoidBias = -1000000000.f;
-float VideoAdapter::FindLowerScale(int width, int height,
-                                   int target_num_pixels) {
-  return FindScale(GetViewScaleFactors(), kUpAvoidBias,
-                   width, height, target_num_pixels);
-}
+namespace cricket {
 
-// There are several frame sizes used by Adapter.  This explains them
-// input_format - set once by server to frame size expected from the camera.
-//   The input frame size is also updated in AdaptFrameResolution.
-// output_format - size that output would like to be.  Includes framerate.
-//   The output frame size is also updated in AdaptFrameResolution.
-// output_num_pixels - size that output should be constrained to.  Used to
-//   compute output_format from in_frame.
-// in_frame - actual camera captured frame size, which is typically the same
-//   as input_format.  This can also be rotated or cropped for aspect ratio.
-// out_frame - actual frame output by adapter.  Should be a direct scale of
-//   in_frame maintaining rotation and aspect ratio.
-// OnOutputFormatRequest - server requests you send this resolution based on
-//   view requests.
-// OnEncoderResolutionRequest - encoder requests you send this resolution based
-//   on bandwidth
-// OnCpuLoadUpdated - cpu monitor requests you send this resolution based on
-//   cpu load.
-
-///////////////////////////////////////////////////////////////////////
-// Implementation of VideoAdapter
 VideoAdapter::VideoAdapter()
-    : output_num_pixels_(INT_MAX),
-      scale_third_(false),
+    : output_num_pixels_(std::numeric_limits<int>::max()),
       frames_in_(0),
       frames_out_(0),
       frames_scaled_(0),
       adaption_changes_(0),
       previous_width_(0),
       previous_height_(0),
-      interval_next_frame_(0) {
-}
+      interval_next_frame_(0),
+      format_request_max_pixel_count_(std::numeric_limits<int>::max()),
+      resolution_request_max_pixel_count_(std::numeric_limits<int>::max()) {}
 
-VideoAdapter::~VideoAdapter() {
+VideoAdapter::~VideoAdapter() {}
+
+void VideoAdapter::SetExpectedInputFrameInterval(int64_t interval) {
+  // TODO(perkj): Consider measuring input frame rate instead.
+  // Frame rate typically varies depending on lighting.
+  rtc::CritScope cs(&critical_section_);
+  input_format_.interval = interval;
 }
 
 void VideoAdapter::SetInputFormat(const VideoFormat& format) {
-  rtc::CritScope cs(&critical_section_);
+  bool is_resolution_change = (input_format().width != format.width ||
+                               input_format().height != format.height);
   int64_t old_input_interval = input_format_.interval;
   input_format_ = format;
   output_format_.interval =
       std::max(output_format_.interval, input_format_.interval);
   if (old_input_interval != input_format_.interval) {
     LOG(LS_INFO) << "VAdapt input interval changed from "
       << old_input_interval << " to " << input_format_.interval;
   }
-}
-
-void CoordinatedVideoAdapter::SetInputFormat(const VideoFormat& format) {
-  int previous_width = input_format().width;
-  int previous_height = input_format().height;
-  bool is_resolution_change = previous_width > 0 && format.width > 0 &&
-                              (previous_width != format.width ||
-                               previous_height != format.height);
-  VideoAdapter::SetInputFormat(format);
   if (is_resolution_change) {
-    int width, height;
     // Trigger the adaptation logic again, to potentially reset the adaptation
     // state for things like view requests that may not longer be capping
     // output (or may now cap output).
-    AdaptToMinimumFormat(&width, &height);
-    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;
+    Adapt(std::min(format_request_max_pixel_count_,
+                   resolution_request_max_pixel_count_),
+          0);
   }
 }
 
-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;
-  }
-}
-
-const VideoFormat& VideoAdapter::input_format() {
+const VideoFormat& VideoAdapter::input_format() const {
   rtc::CritScope cs(&critical_section_);
   return input_format_;
 }
 
-bool VideoAdapter::drops_all_frames() const {
-  return output_num_pixels_ == 0;
-}
-
-const VideoFormat& VideoAdapter::output_format() {
-  rtc::CritScope cs(&critical_section_);
-  return output_format_;
-}
-
-// Constrain output resolution to this many pixels overall
-void VideoAdapter::SetOutputNumPixels(int num_pixels) {
-  output_num_pixels_ = num_pixels;
-}
-
-int VideoAdapter::GetOutputNumPixels() const {
-  return output_num_pixels_;
-}
-
 VideoFormat VideoAdapter::AdaptFrameResolution(int in_width, int in_height) {
   rtc::CritScope cs(&critical_section_);
   ++frames_in_;
 
   SetInputFormat(VideoFormat(
       in_width, in_height, input_format_.interval, input_format_.fourcc));
 
   // Drop the input frame if necessary.
   bool should_drop = false;
   if (!output_num_pixels_) {
     // Drop all frames as the output format is 0x0.
     should_drop = true;
   } else {
     // Drop some frames based on input fps and output fps.
     // Normally output fps is less than input fps.
-    // TODO(fbarchard): Consider adjusting interval to reflect the adjusted
-    // interval between frames after dropping some frames.
     interval_next_frame_ += input_format_.interval;
     if (output_format_.interval > 0) {
       if (interval_next_frame_ >= output_format_.interval) {
         interval_next_frame_ %= output_format_.interval;
       } else {
         should_drop = true;
       }
     }
   }
   if (should_drop) {
     // Show VAdapt log every 90 frames dropped. (3 seconds)
     if ((frames_in_ - frames_out_) % 90 == 0) {
       // TODO(fbarchard): Reduce to LS_VERBOSE when adapter info is not needed
       // in default calls.
       LOG(LS_INFO) << "VAdapt Drop Frame: scaled " << frames_scaled_
                    << " / out " << frames_out_
                    << " / in " << frames_in_
                    << " Changes: " << adaption_changes_
                    << " Input: " << in_width
                    << "x" << in_height
                    << " i" << input_format_.interval
                    << " Output: i" << output_format_.interval;
     }
 
     return VideoFormat();  // Drop frame.
   }
 
-  const float scale = VideoAdapter::FindClosestViewScale(
-      in_width, in_height, output_num_pixels_);
-  const size_t output_width = static_cast<size_t>(in_width * scale + .5f);
-  const size_t output_height = static_cast<size_t>(in_height * scale + .5f);
+  const float scale = FindScaleLessThanOrEqual(in_width, in_height,
+                                               output_num_pixels_, nullptr);
+  const int output_width = static_cast<int>(in_width * scale + .5f);
+  const int output_height = static_cast<int>(in_height * scale + .5f);
 
   ++frames_out_;
   if (scale != 1)
     ++frames_scaled_;
-  // Show VAdapt log every 90 frames output. (3 seconds)
-  // TODO(fbarchard): Consider GetLogSeverity() to change interval to less
-  // for LS_VERBOSE and more for LS_INFO.
-  bool show = (frames_out_) % 90 == 0;
 
-  // TODO(fbarchard): LOG the previous output resolution and track input
-  // resolution changes as well.  Consider dropping the statistics into their
-  // own class which could be queried publically.
-  bool changed = false;
   if (previous_width_ && (previous_width_ != output_width ||
                           previous_height_ != output_height)) {
-    show = true;
     ++adaption_changes_;
-    changed = true;
-  }
-  if (show) {
-    // TODO(fbarchard): Reduce to LS_VERBOSE when adapter info is not needed
-    // in default calls.
-    LOG(LS_INFO) << "VAdapt Frame: scaled " << frames_scaled_
-                 << " / out " << frames_out_
-                 << " / in " << frames_in_
-                 << " Changes: " << adaption_changes_
-                 << " Input: " << in_width
-                 << "x" << in_height
-                 << " i" << input_format_.interval
-                 << " Scale: " << scale
-                 << " Output: " << output_width
-                 << "x" << output_height
-                 << " i" << output_format_.interval
-                 << " Changed: " << (changed ? "true" : "false");
+    LOG(LS_INFO) << "Frame size changed: scaled " << frames_scaled_ << " / out "
+                 << frames_out_ << " / in " << frames_in_
+                 << " Changes: " << adaption_changes_ << " Input: " << in_width
+                 << "x" << in_height << " i" << input_format_.interval
+                 << " Scale: " << scale << " Output: " << output_width << "x"
+                 << output_height << " i" << output_format_.interval;
   }
 
   output_format_.width = output_width;
   output_format_.height = output_height;
   previous_width_ = output_width;
   previous_height_ = output_height;
 
   return output_format_;
 }
 
-void VideoAdapter::set_scale_third(bool enable) {
-  LOG(LS_INFO) << "Video Adapter third scaling is now "
-               << (enable ? "enabled" : "disabled");
-  scale_third_ = enable;
+void VideoAdapter::OnOutputFormatRequest(const VideoFormat& format) {
+  rtc::CritScope cs(&critical_section_);
+  format_request_max_pixel_count_ = format.width * format.height;
+  output_format_.interval = format.interval;
+  Adapt(std::min(format_request_max_pixel_count_,
+                 resolution_request_max_pixel_count_),
+        0);
 }
 
-///////////////////////////////////////////////////////////////////////
-// 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) {
+void VideoAdapter::OnResolutionRequest(
+    rtc::Optional<int> max_pixel_count,
+    rtc::Optional<int> max_pixel_count_step_up) {
+  rtc::CritScope cs(&critical_section_);
+  resolution_request_max_pixel_count_ =
+      max_pixel_count.value_or(std::numeric_limits<int>::max());
+  Adapt(std::min(format_request_max_pixel_count_,
+                 resolution_request_max_pixel_count_),
+        max_pixel_count_step_up.value_or(0));
 }
 
-// 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;
+bool VideoAdapter::Adapt(int max_num_pixels, int max_pixel_count_step_up) {
+  float scale_lower =
+      FindScaleLessThanOrEqual(input_format_.width, input_format_.height,
+                               max_num_pixels, &max_num_pixels);
+  float scale_upper =
+      max_pixel_count_step_up > 0
+          ? FindScaleLargerThan(input_format_.width, input_format_.height,
+                                max_pixel_count_step_up,
+                                &max_pixel_count_step_up)
+          : 1.f;
 
-    case CoordinatedVideoAdapter::UPGRADE:
-      *num_pixels *= 2;
-      break;
+  bool use_max_pixel_count_step_up =
+      max_pixel_count_step_up > 0 && max_num_pixels > max_pixel_count_step_up;
 
-    default:  // No change in pixel count
-      break;
-  }
-  return;
-}
+  int old_num_pixels = output_num_pixels_;
+  output_num_pixels_ =
+      use_max_pixel_count_step_up ? max_pixel_count_step_up : max_num_pixels;
+  // Log the new size.
+  float scale = use_max_pixel_count_step_up ? scale_upper : scale_lower;
+  int new_width = static_cast<int>(input_format_.width * scale + .5f);
+  int new_height = static_cast<int>(input_format_.height * scale + .5f);
 
-// 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;
-    int old_num_pixels = GetOutputNumPixels();
-    if (new_encoder_desired_num_pixels != old_num_pixels) {
-      LOG(LS_VERBOSE) << "VAdapt GD resolution stale.  Ignored";
-    } else {
-      // Update the encoder desired format based on the request.
-      encoder_desired_num_pixels_ = new_encoder_desired_num_pixels;
-      StepPixelCount(request, &encoder_desired_num_pixels_);
-    }
-  }
-  int new_width, new_height;
-  bool changed = AdaptToMinimumFormat(&new_width, &new_height);
-
-  // Ignore up or keep if no change.
-  if (DOWNGRADE != request && view_switch_ && !changed) {
-    encoder_desired_num_pixels_ = old_encoder_desired_num_pixels;
-    LOG(LS_VERBOSE) << "VAdapt ignoring GD request.";
-  }
-
-  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;
-}
-
-void CoordinatedVideoAdapter::OnCpuResolutionRequest(
-    rtc::Optional<int> max_pixel_count,
-    rtc::Optional<int> max_pixel_count_step_up) {
-  rtc::CritScope cs(&request_critical_section_);
-  // TODO(perkj): We should support taking larger steps up and down and
-  // actually look at the values set in max_pixel_count and
-  // max_pixel_count_step_up.
-  if (max_pixel_count && *max_pixel_count < GetOutputNumPixels()) {
-    OnCpuResolutionRequest(DOWNGRADE);
-  } else if (max_pixel_count_step_up &&
-             *max_pixel_count_step_up >= GetOutputNumPixels()) {
-    OnCpuResolutionRequest(UPGRADE);
-  }
-}
-
-// A Bandwidth GD request for new resolution
-void CoordinatedVideoAdapter::OnCpuResolutionRequest(AdaptRequest request) {
-  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;
-  }
-  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_);
-  }
-  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_
-               << " 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;
-  }
-  float scale = 1.0f;
-  if (!input.IsSize0x0()) {
-    scale = FindClosestScale(input.width,
-                             input.height,
-                             pixels);
-  }
-  new_output.width = static_cast<int>(input.width * scale + .5f);
-  new_output.height = static_cast<int>(input.height * scale + .5f);
-  int new_pixels = new_output.width * new_output.height;
-  int num_pixels = GetOutputNumPixels();
-  return new_pixels <= num_pixels;
-}
-
-// Called by all coordinators when there is a change.
-bool CoordinatedVideoAdapter::AdaptToMinimumFormat(int* new_width,
-                                                   int* new_height) {
-  VideoFormat new_output = output_format();
-  VideoFormat input = input_format();
-  if (input_format().IsSize0x0()) {
-    input = new_output;
-  }
-  int old_num_pixels = GetOutputNumPixels();
-  int min_num_pixels = INT_MAX;
-  adapt_reason_ = ADAPTREASON_NONE;
-
-  // Reduce resolution based on encoder bandwidth (GD).
-  if (encoder_desired_num_pixels_ &&
-      (encoder_desired_num_pixels_ < min_num_pixels)) {
-    adapt_reason_ |= ADAPTREASON_BANDWIDTH;
-    min_num_pixels = encoder_desired_num_pixels_;
-  }
-  // Reduce resolution based on CPU.
-  if (cpu_adaptation_ && cpu_desired_num_pixels_ &&
-      (cpu_desired_num_pixels_ <= min_num_pixels)) {
-    if (cpu_desired_num_pixels_ < min_num_pixels) {
-      adapt_reason_ = ADAPTREASON_CPU;
-    } else {
-      adapt_reason_ |= ADAPTREASON_CPU;
-    }
-    min_num_pixels = cpu_desired_num_pixels_;
-  }
-  // Round resolution for GD or CPU to allow 1/2 to map to 9/16.
-  if (!input.IsSize0x0() && min_num_pixels != INT_MAX) {
-    float scale = FindClosestScale(input.width, input.height, min_num_pixels);
-    min_num_pixels = static_cast<int>(input.width * scale + .5f) *
-        static_cast<int>(input.height * scale + .5f);
-  }
-  // Reduce resolution based on View Request.
-  if (view_desired_num_pixels_ <= min_num_pixels) {
-    if (view_desired_num_pixels_ < min_num_pixels) {
-      adapt_reason_ = ADAPTREASON_VIEW;
-    } else {
-      adapt_reason_ |= ADAPTREASON_VIEW;
-    }
-    min_num_pixels = view_desired_num_pixels_;
-  }
-  // Snap to a scale factor.
-  float scale = 1.0f;
-  if (!input.IsSize0x0()) {
-    scale = FindLowerScale(input.width, input.height, min_num_pixels);
-    min_num_pixels = static_cast<int>(input.width * scale + .5f) *
-        static_cast<int>(input.height * scale + .5f);
-  }
-  if (scale == 1.0f) {
-    adapt_reason_ = ADAPTREASON_NONE;
-  }
-  *new_width = new_output.width = static_cast<int>(input.width * scale + .5f);
-  *new_height = new_output.height = static_cast<int>(input.height * scale +
-                                                     .5f);
-  SetOutputNumPixels(min_num_pixels);
-
-  new_output.interval = view_desired_interval_;
-  SetOutputFormat(new_output);
-  int new_num_pixels = GetOutputNumPixels();
-  bool changed = new_num_pixels != old_num_pixels;
-
-  static const char* kReasons[8] = {
-    "None",
-    "CPU",
-    "BANDWIDTH",
-    "CPU+BANDWIDTH",
-    "VIEW",
-    "CPU+VIEW",
-    "BANDWIDTH+VIEW",
-    "CPU+BANDWIDTH+VIEW",
-  };
-
-  LOG(LS_VERBOSE) << "VAdapt Status View: " << view_desired_num_pixels_
-                  << " GD: " << encoder_desired_num_pixels_
-                  << " 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;
-  }
+  bool changed = output_num_pixels_ != old_num_pixels;
+  LOG(LS_INFO) << "OnResolutionRequest: "
+               << " Max pixels: " << max_num_pixels
+               << " Max pixels step up: " << max_pixel_count_step_up
+               << " Output Pixels: " << output_num_pixels_
+               << " Input: " << input_format_.width << "x"
+               << input_format_.height << " Scale: " << scale
+               << " Resolution: " << new_width << "x" << new_height
+               << " Changed: " << (changed ? "true" : "false");
 
   return changed;
 }
 
 }  // namespace cricket