/*
* 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,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "talk/media/base/videoadapter.h"
#include <limits.h> // For INT_MAX
#include <algorithm>
#include "talk/media/base/constants.h"
#include "talk/media/base/videocommon.h"
#include "talk/media/base/videoframe.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/timeutils.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.
};
// 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 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;
}
if (diff < best_distance) {
best_distance = diff;
best_scale = scale;
if (best_distance == 0) { // Found exact match.
break;
}
}
}
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);
}
// 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);
}
// 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);
}
// 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),
frames_in_(0),
frames_out_(0),
frames_scaled_(0),
adaption_changes_(0),
previous_width_(0),
previous_height_(0),
interval_next_frame_(0) {
}
VideoAdapter::~VideoAdapter() {
}
void VideoAdapter::SetInputFormat(const VideoFormat& format) {
rtc::CritScope cs(&critical_section_);
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;
}
}
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() {
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 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");
}
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;
}
///////////////////////////////////////////////////////////////////////
// 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) {
}
// 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;
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;
}
// 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;
}
return changed;
}
} // namespace cricket