622 lines
26 KiB
C++
622 lines
26 KiB
C++
/*
|
|
* Copyright 2019 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
// #define LOG_NDEBUG 0
|
|
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
|
|
#include "RefreshRateConfigs.h"
|
|
#include <android-base/stringprintf.h>
|
|
#include <utils/Trace.h>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "RefreshRateConfigs"
|
|
|
|
namespace android::scheduler {
|
|
|
|
using AllRefreshRatesMapType = RefreshRateConfigs::AllRefreshRatesMapType;
|
|
using RefreshRate = RefreshRateConfigs::RefreshRate;
|
|
|
|
std::string RefreshRateConfigs::layerVoteTypeString(LayerVoteType vote) {
|
|
switch (vote) {
|
|
case LayerVoteType::NoVote:
|
|
return "NoVote";
|
|
case LayerVoteType::Min:
|
|
return "Min";
|
|
case LayerVoteType::Max:
|
|
return "Max";
|
|
case LayerVoteType::Heuristic:
|
|
return "Heuristic";
|
|
case LayerVoteType::ExplicitDefault:
|
|
return "ExplicitDefault";
|
|
case LayerVoteType::ExplicitExactOrMultiple:
|
|
return "ExplicitExactOrMultiple";
|
|
}
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getRefreshRateForContent(
|
|
const std::vector<LayerRequirement>& layers) const {
|
|
std::lock_guard lock(mLock);
|
|
int contentFramerate = 0;
|
|
int explicitContentFramerate = 0;
|
|
for (const auto& layer : layers) {
|
|
const auto desiredRefreshRateRound = round<int>(layer.desiredRefreshRate);
|
|
if (layer.vote == LayerVoteType::ExplicitDefault ||
|
|
layer.vote == LayerVoteType::ExplicitExactOrMultiple) {
|
|
if (desiredRefreshRateRound > explicitContentFramerate) {
|
|
explicitContentFramerate = desiredRefreshRateRound;
|
|
}
|
|
} else {
|
|
if (desiredRefreshRateRound > contentFramerate) {
|
|
contentFramerate = desiredRefreshRateRound;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (explicitContentFramerate != 0) {
|
|
contentFramerate = explicitContentFramerate;
|
|
} else if (contentFramerate == 0) {
|
|
contentFramerate = round<int>(mMaxSupportedRefreshRate->getFps());
|
|
}
|
|
ATRACE_INT("ContentFPS", contentFramerate);
|
|
|
|
// Find the appropriate refresh rate with minimal error
|
|
auto iter = min_element(mPrimaryRefreshRates.cbegin(), mPrimaryRefreshRates.cend(),
|
|
[contentFramerate](const auto& lhs, const auto& rhs) -> bool {
|
|
return std::abs(lhs->fps - contentFramerate) <
|
|
std::abs(rhs->fps - contentFramerate);
|
|
});
|
|
|
|
// Some content aligns better on higher refresh rate. For example for 45fps we should choose
|
|
// 90Hz config. However we should still prefer a lower refresh rate if the content doesn't
|
|
// align well with both
|
|
const RefreshRate* bestSoFar = *iter;
|
|
constexpr float MARGIN = 0.05f;
|
|
float ratio = (*iter)->fps / contentFramerate;
|
|
if (std::abs(std::round(ratio) - ratio) > MARGIN) {
|
|
while (iter != mPrimaryRefreshRates.cend()) {
|
|
ratio = (*iter)->fps / contentFramerate;
|
|
|
|
if (std::abs(std::round(ratio) - ratio) <= MARGIN) {
|
|
bestSoFar = *iter;
|
|
break;
|
|
}
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
return *bestSoFar;
|
|
}
|
|
|
|
std::pair<nsecs_t, nsecs_t> RefreshRateConfigs::getDisplayFrames(nsecs_t layerPeriod,
|
|
nsecs_t displayPeriod) const {
|
|
auto [displayFramesQuot, displayFramesRem] = std::div(layerPeriod, displayPeriod);
|
|
if (displayFramesRem <= MARGIN_FOR_PERIOD_CALCULATION ||
|
|
std::abs(displayFramesRem - displayPeriod) <= MARGIN_FOR_PERIOD_CALCULATION) {
|
|
displayFramesQuot++;
|
|
displayFramesRem = 0;
|
|
}
|
|
|
|
return {displayFramesQuot, displayFramesRem};
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getBestRefreshRate(
|
|
const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
|
|
GlobalSignals* outSignalsConsidered) const {
|
|
ATRACE_CALL();
|
|
ALOGV("getRefreshRateForContent %zu layers", layers.size());
|
|
|
|
if (outSignalsConsidered) *outSignalsConsidered = {};
|
|
const auto setTouchConsidered = [&] {
|
|
if (outSignalsConsidered) {
|
|
outSignalsConsidered->touch = true;
|
|
}
|
|
};
|
|
|
|
const auto setIdleConsidered = [&] {
|
|
if (outSignalsConsidered) {
|
|
outSignalsConsidered->idle = true;
|
|
}
|
|
};
|
|
|
|
std::lock_guard lock(mLock);
|
|
|
|
int noVoteLayers = 0;
|
|
int minVoteLayers = 0;
|
|
int maxVoteLayers = 0;
|
|
int explicitDefaultVoteLayers = 0;
|
|
int explicitExactOrMultipleVoteLayers = 0;
|
|
float maxExplicitWeight = 0;
|
|
for (const auto& layer : layers) {
|
|
if (layer.vote == LayerVoteType::NoVote) {
|
|
noVoteLayers++;
|
|
} else if (layer.vote == LayerVoteType::Min) {
|
|
minVoteLayers++;
|
|
} else if (layer.vote == LayerVoteType::Max) {
|
|
maxVoteLayers++;
|
|
} else if (layer.vote == LayerVoteType::ExplicitDefault) {
|
|
explicitDefaultVoteLayers++;
|
|
maxExplicitWeight = std::max(maxExplicitWeight, layer.weight);
|
|
} else if (layer.vote == LayerVoteType::ExplicitExactOrMultiple) {
|
|
explicitExactOrMultipleVoteLayers++;
|
|
maxExplicitWeight = std::max(maxExplicitWeight, layer.weight);
|
|
}
|
|
}
|
|
|
|
const bool hasExplicitVoteLayers =
|
|
explicitDefaultVoteLayers > 0 || explicitExactOrMultipleVoteLayers > 0;
|
|
|
|
// Consider the touch event if there are no Explicit* layers. Otherwise wait until after we've
|
|
// selected a refresh rate to see if we should apply touch boost.
|
|
if (globalSignals.touch && !hasExplicitVoteLayers) {
|
|
ALOGV("TouchBoost - choose %s", getMaxRefreshRateByPolicyLocked().getName().c_str());
|
|
setTouchConsidered();
|
|
return getMaxRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
// If the primary range consists of a single refresh rate then we can only
|
|
// move out the of range if layers explicitly request a different refresh
|
|
// rate.
|
|
const Policy* policy = getCurrentPolicyLocked();
|
|
const bool primaryRangeIsSingleRate = policy->primaryRange.min == policy->primaryRange.max;
|
|
|
|
if (!globalSignals.touch && globalSignals.idle &&
|
|
!(primaryRangeIsSingleRate && hasExplicitVoteLayers)) {
|
|
ALOGV("Idle - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
|
|
setIdleConsidered();
|
|
return getMinRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
if (layers.empty() || noVoteLayers == layers.size()) {
|
|
return getMaxRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
// Only if all layers want Min we should return Min
|
|
if (noVoteLayers + minVoteLayers == layers.size()) {
|
|
ALOGV("all layers Min - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
|
|
return getMinRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
// Find the best refresh rate based on score
|
|
std::vector<std::pair<const RefreshRate*, float>> scores;
|
|
scores.reserve(mAppRequestRefreshRates.size());
|
|
|
|
for (const auto refreshRate : mAppRequestRefreshRates) {
|
|
scores.emplace_back(refreshRate, 0.0f);
|
|
}
|
|
|
|
for (const auto& layer : layers) {
|
|
ALOGV("Calculating score for %s (%s, weight %.2f)", layer.name.c_str(),
|
|
layerVoteTypeString(layer.vote).c_str(), layer.weight);
|
|
if (layer.vote == LayerVoteType::NoVote || layer.vote == LayerVoteType::Min) {
|
|
continue;
|
|
}
|
|
|
|
auto weight = layer.weight;
|
|
|
|
for (auto i = 0u; i < scores.size(); i++) {
|
|
bool inPrimaryRange =
|
|
scores[i].first->inPolicy(policy->primaryRange.min, policy->primaryRange.max);
|
|
if ((primaryRangeIsSingleRate || !inPrimaryRange) &&
|
|
!(layer.focused && layer.vote == LayerVoteType::ExplicitDefault)) {
|
|
// Only focused layers with ExplicitDefault frame rate settings are allowed to score
|
|
// refresh rates outside the primary range.
|
|
continue;
|
|
}
|
|
|
|
// If the layer wants Max, give higher score to the higher refresh rate
|
|
if (layer.vote == LayerVoteType::Max) {
|
|
const auto ratio = scores[i].first->fps / scores.back().first->fps;
|
|
// use ratio^2 to get a lower score the more we get further from peak
|
|
const auto layerScore = ratio * ratio;
|
|
ALOGV("%s (Max, weight %.2f) gives %s score of %.2f", layer.name.c_str(), weight,
|
|
scores[i].first->name.c_str(), layerScore);
|
|
scores[i].second += weight * layerScore;
|
|
continue;
|
|
}
|
|
|
|
const auto displayPeriod = scores[i].first->hwcConfig->getVsyncPeriod();
|
|
const auto layerPeriod = round<nsecs_t>(1e9f / layer.desiredRefreshRate);
|
|
if (layer.vote == LayerVoteType::ExplicitDefault) {
|
|
const auto layerScore = [&]() {
|
|
// Find the actual rate the layer will render, assuming
|
|
// that layerPeriod is the minimal time to render a frame
|
|
auto actualLayerPeriod = displayPeriod;
|
|
int multiplier = 1;
|
|
while (layerPeriod > actualLayerPeriod + MARGIN_FOR_PERIOD_CALCULATION) {
|
|
multiplier++;
|
|
actualLayerPeriod = displayPeriod * multiplier;
|
|
}
|
|
return std::min(1.0f,
|
|
static_cast<float>(layerPeriod) /
|
|
static_cast<float>(actualLayerPeriod));
|
|
}();
|
|
|
|
ALOGV("%s (ExplicitDefault, weight %.2f) %.2fHz gives %s score of %.2f",
|
|
layer.name.c_str(), weight, 1e9f / layerPeriod, scores[i].first->name.c_str(),
|
|
layerScore);
|
|
scores[i].second += weight * layerScore;
|
|
continue;
|
|
}
|
|
|
|
if (layer.vote == LayerVoteType::ExplicitExactOrMultiple ||
|
|
layer.vote == LayerVoteType::Heuristic) {
|
|
const auto layerScore = [&] {
|
|
// Calculate how many display vsyncs we need to present a single frame for this
|
|
// layer
|
|
const auto [displayFramesQuot, displayFramesRem] =
|
|
getDisplayFrames(layerPeriod, displayPeriod);
|
|
static constexpr size_t MAX_FRAMES_TO_FIT =
|
|
10; // Stop calculating when score < 0.1
|
|
if (displayFramesRem == 0) {
|
|
// Layer desired refresh rate matches the display rate.
|
|
return 1.0f;
|
|
}
|
|
|
|
if (displayFramesQuot == 0) {
|
|
// Layer desired refresh rate is higher the display rate.
|
|
return (static_cast<float>(layerPeriod) /
|
|
static_cast<float>(displayPeriod)) *
|
|
(1.0f / (MAX_FRAMES_TO_FIT + 1));
|
|
}
|
|
|
|
// Layer desired refresh rate is lower the display rate. Check how well it fits
|
|
// the cadence
|
|
auto diff = std::abs(displayFramesRem - (displayPeriod - displayFramesRem));
|
|
int iter = 2;
|
|
while (diff > MARGIN_FOR_PERIOD_CALCULATION && iter < MAX_FRAMES_TO_FIT) {
|
|
diff = diff - (displayPeriod - diff);
|
|
iter++;
|
|
}
|
|
|
|
return 1.0f / iter;
|
|
}();
|
|
ALOGV("%s (%s, weight %.2f) %.2fHz gives %s score of %.2f", layer.name.c_str(),
|
|
layerVoteTypeString(layer.vote).c_str(), weight, 1e9f / layerPeriod,
|
|
scores[i].first->name.c_str(), layerScore);
|
|
scores[i].second += weight * layerScore;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now that we scored all the refresh rates we need to pick the one that got the highest score.
|
|
// In case of a tie we will pick the higher refresh rate if any of the layers wanted Max,
|
|
// or the lower otherwise.
|
|
const RefreshRate* bestRefreshRate = maxVoteLayers > 0
|
|
? getBestRefreshRate(scores.rbegin(), scores.rend())
|
|
: getBestRefreshRate(scores.begin(), scores.end());
|
|
|
|
if (primaryRangeIsSingleRate) {
|
|
// If we never scored any layers, then choose the rate from the primary
|
|
// range instead of picking a random score from the app range.
|
|
if (std::all_of(scores.begin(), scores.end(),
|
|
[](std::pair<const RefreshRate*, float> p) { return p.second == 0; })) {
|
|
ALOGV("layers not scored - choose %s",
|
|
getMaxRefreshRateByPolicyLocked().getName().c_str());
|
|
return getMaxRefreshRateByPolicyLocked();
|
|
} else {
|
|
return *bestRefreshRate;
|
|
}
|
|
}
|
|
|
|
// Consider the touch event if there are no ExplicitDefault layers. ExplicitDefault are mostly
|
|
// interactive (as opposed to ExplicitExactOrMultiple) and therefore if those posted an explicit
|
|
// vote we should not change it if we get a touch event. Only apply touch boost if it will
|
|
// actually increase the refresh rate over the normal selection.
|
|
const RefreshRate& touchRefreshRate = getMaxRefreshRateByPolicyLocked();
|
|
|
|
if (globalSignals.touch && explicitDefaultVoteLayers == 0 &&
|
|
bestRefreshRate->fps < touchRefreshRate.fps) {
|
|
setTouchConsidered();
|
|
ALOGV("TouchBoost - choose %s", touchRefreshRate.getName().c_str());
|
|
return touchRefreshRate;
|
|
}
|
|
|
|
return *bestRefreshRate;
|
|
}
|
|
|
|
template <typename Iter>
|
|
const RefreshRate* RefreshRateConfigs::getBestRefreshRate(Iter begin, Iter end) const {
|
|
constexpr auto EPSILON = 0.001f;
|
|
const RefreshRate* bestRefreshRate = begin->first;
|
|
float max = begin->second;
|
|
for (auto i = begin; i != end; ++i) {
|
|
const auto [refreshRate, score] = *i;
|
|
ALOGV("%s scores %.2f", refreshRate->name.c_str(), score);
|
|
|
|
ATRACE_INT(refreshRate->name.c_str(), round<int>(score * 100));
|
|
|
|
if (score > max * (1 + EPSILON)) {
|
|
max = score;
|
|
bestRefreshRate = refreshRate;
|
|
}
|
|
}
|
|
|
|
return bestRefreshRate;
|
|
}
|
|
|
|
const AllRefreshRatesMapType& RefreshRateConfigs::getAllRefreshRates() const {
|
|
return mRefreshRates;
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMinRefreshRateByPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return getMinRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMinRefreshRateByPolicyLocked() const {
|
|
return *mPrimaryRefreshRates.front();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMaxRefreshRateByPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return getMaxRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMaxRefreshRateByPolicyLocked() const {
|
|
return *mPrimaryRefreshRates.back();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getCurrentRefreshRate() const {
|
|
std::lock_guard lock(mLock);
|
|
return *mCurrentRefreshRate;
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getCurrentRefreshRateByPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return getCurrentRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getCurrentRefreshRateByPolicyLocked() const {
|
|
if (std::find(mAppRequestRefreshRates.begin(), mAppRequestRefreshRates.end(),
|
|
mCurrentRefreshRate) != mAppRequestRefreshRates.end()) {
|
|
return *mCurrentRefreshRate;
|
|
}
|
|
return *mRefreshRates.at(getCurrentPolicyLocked()->defaultConfig);
|
|
}
|
|
|
|
void RefreshRateConfigs::setCurrentConfigId(HwcConfigIndexType configId) {
|
|
std::lock_guard lock(mLock);
|
|
mCurrentRefreshRate = mRefreshRates.at(configId).get();
|
|
}
|
|
|
|
RefreshRateConfigs::RefreshRateConfigs(
|
|
const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
|
|
HwcConfigIndexType currentConfigId)
|
|
: mKnownFrameRates(constructKnownFrameRates(configs)) {
|
|
LOG_ALWAYS_FATAL_IF(configs.empty());
|
|
LOG_ALWAYS_FATAL_IF(currentConfigId.value() >= configs.size());
|
|
|
|
for (auto configId = HwcConfigIndexType(0); configId.value() < configs.size(); configId++) {
|
|
const auto& config = configs.at(static_cast<size_t>(configId.value()));
|
|
const float fps = 1e9f / config->getVsyncPeriod();
|
|
mRefreshRates.emplace(configId,
|
|
std::make_unique<RefreshRate>(configId, config,
|
|
base::StringPrintf("%.0ffps", fps), fps,
|
|
RefreshRate::ConstructorTag(0)));
|
|
if (configId == currentConfigId) {
|
|
mCurrentRefreshRate = mRefreshRates.at(configId).get();
|
|
}
|
|
}
|
|
|
|
std::vector<const RefreshRate*> sortedConfigs;
|
|
getSortedRefreshRateList([](const RefreshRate&) { return true; }, &sortedConfigs);
|
|
mDisplayManagerPolicy.defaultConfig = currentConfigId;
|
|
mMinSupportedRefreshRate = sortedConfigs.front();
|
|
mMaxSupportedRefreshRate = sortedConfigs.back();
|
|
constructAvailableRefreshRates();
|
|
}
|
|
|
|
bool RefreshRateConfigs::isPolicyValid(const Policy& policy) {
|
|
// defaultConfig must be a valid config, and within the given refresh rate range.
|
|
auto iter = mRefreshRates.find(policy.defaultConfig);
|
|
if (iter == mRefreshRates.end()) {
|
|
return false;
|
|
}
|
|
const RefreshRate& refreshRate = *iter->second;
|
|
if (!refreshRate.inPolicy(policy.primaryRange.min, policy.primaryRange.max)) {
|
|
return false;
|
|
}
|
|
return policy.appRequestRange.min <= policy.primaryRange.min &&
|
|
policy.appRequestRange.max >= policy.primaryRange.max;
|
|
}
|
|
|
|
status_t RefreshRateConfigs::setDisplayManagerPolicy(const Policy& policy) {
|
|
std::lock_guard lock(mLock);
|
|
if (!isPolicyValid(policy)) {
|
|
return BAD_VALUE;
|
|
}
|
|
Policy previousPolicy = *getCurrentPolicyLocked();
|
|
mDisplayManagerPolicy = policy;
|
|
if (*getCurrentPolicyLocked() == previousPolicy) {
|
|
return CURRENT_POLICY_UNCHANGED;
|
|
}
|
|
constructAvailableRefreshRates();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
status_t RefreshRateConfigs::setOverridePolicy(const std::optional<Policy>& policy) {
|
|
std::lock_guard lock(mLock);
|
|
if (policy && !isPolicyValid(*policy)) {
|
|
return BAD_VALUE;
|
|
}
|
|
Policy previousPolicy = *getCurrentPolicyLocked();
|
|
mOverridePolicy = policy;
|
|
if (*getCurrentPolicyLocked() == previousPolicy) {
|
|
return CURRENT_POLICY_UNCHANGED;
|
|
}
|
|
constructAvailableRefreshRates();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
const RefreshRateConfigs::Policy* RefreshRateConfigs::getCurrentPolicyLocked() const {
|
|
return mOverridePolicy ? &mOverridePolicy.value() : &mDisplayManagerPolicy;
|
|
}
|
|
|
|
RefreshRateConfigs::Policy RefreshRateConfigs::getCurrentPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return *getCurrentPolicyLocked();
|
|
}
|
|
|
|
RefreshRateConfigs::Policy RefreshRateConfigs::getDisplayManagerPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return mDisplayManagerPolicy;
|
|
}
|
|
|
|
bool RefreshRateConfigs::isConfigAllowed(HwcConfigIndexType config) const {
|
|
std::lock_guard lock(mLock);
|
|
for (const RefreshRate* refreshRate : mAppRequestRefreshRates) {
|
|
if (refreshRate->configId == config) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void RefreshRateConfigs::getSortedRefreshRateList(
|
|
const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
|
|
std::vector<const RefreshRate*>* outRefreshRates) {
|
|
outRefreshRates->clear();
|
|
outRefreshRates->reserve(mRefreshRates.size());
|
|
for (const auto& [type, refreshRate] : mRefreshRates) {
|
|
if (shouldAddRefreshRate(*refreshRate)) {
|
|
ALOGV("getSortedRefreshRateList: config %d added to list policy",
|
|
refreshRate->configId.value());
|
|
outRefreshRates->push_back(refreshRate.get());
|
|
}
|
|
}
|
|
|
|
std::sort(outRefreshRates->begin(), outRefreshRates->end(),
|
|
[](const auto refreshRate1, const auto refreshRate2) {
|
|
if (refreshRate1->hwcConfig->getVsyncPeriod() !=
|
|
refreshRate2->hwcConfig->getVsyncPeriod()) {
|
|
return refreshRate1->hwcConfig->getVsyncPeriod() >
|
|
refreshRate2->hwcConfig->getVsyncPeriod();
|
|
} else {
|
|
return refreshRate1->hwcConfig->getConfigGroup() >
|
|
refreshRate2->hwcConfig->getConfigGroup();
|
|
}
|
|
});
|
|
}
|
|
|
|
void RefreshRateConfigs::constructAvailableRefreshRates() {
|
|
// Filter configs based on current policy and sort based on vsync period
|
|
const Policy* policy = getCurrentPolicyLocked();
|
|
const auto& defaultConfig = mRefreshRates.at(policy->defaultConfig)->hwcConfig;
|
|
ALOGV("constructAvailableRefreshRates: default %d group %d primaryRange=[%.2f %.2f]"
|
|
" appRequestRange=[%.2f %.2f]",
|
|
policy->defaultConfig.value(), defaultConfig->getConfigGroup(), policy->primaryRange.min,
|
|
policy->primaryRange.max, policy->appRequestRange.min, policy->appRequestRange.max);
|
|
|
|
auto filterRefreshRates = [&](float min, float max, const char* listName,
|
|
std::vector<const RefreshRate*>* outRefreshRates) {
|
|
getSortedRefreshRateList(
|
|
[&](const RefreshRate& refreshRate) REQUIRES(mLock) {
|
|
const auto& hwcConfig = refreshRate.hwcConfig;
|
|
|
|
return hwcConfig->getHeight() == defaultConfig->getHeight() &&
|
|
hwcConfig->getWidth() == defaultConfig->getWidth() &&
|
|
hwcConfig->getDpiX() == defaultConfig->getDpiX() &&
|
|
hwcConfig->getDpiY() == defaultConfig->getDpiY() &&
|
|
(policy->allowGroupSwitching ||
|
|
hwcConfig->getConfigGroup() == defaultConfig->getConfigGroup()) &&
|
|
refreshRate.inPolicy(min, max);
|
|
},
|
|
outRefreshRates);
|
|
|
|
LOG_ALWAYS_FATAL_IF(outRefreshRates->empty(),
|
|
"No matching configs for %s range: min=%.0f max=%.0f", listName, min,
|
|
max);
|
|
auto stringifyRefreshRates = [&]() -> std::string {
|
|
std::string str;
|
|
for (auto refreshRate : *outRefreshRates) {
|
|
base::StringAppendF(&str, "%s ", refreshRate->name.c_str());
|
|
}
|
|
return str;
|
|
};
|
|
ALOGV("%s refresh rates: %s", listName, stringifyRefreshRates().c_str());
|
|
};
|
|
|
|
filterRefreshRates(policy->primaryRange.min, policy->primaryRange.max, "primary",
|
|
&mPrimaryRefreshRates);
|
|
filterRefreshRates(policy->appRequestRange.min, policy->appRequestRange.max, "app request",
|
|
&mAppRequestRefreshRates);
|
|
}
|
|
|
|
std::vector<float> RefreshRateConfigs::constructKnownFrameRates(
|
|
const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs) {
|
|
std::vector<float> knownFrameRates = {24.0f, 30.0f, 45.0f, 60.0f, 72.0f};
|
|
knownFrameRates.reserve(knownFrameRates.size() + configs.size());
|
|
|
|
// Add all supported refresh rates to the set
|
|
for (const auto& config : configs) {
|
|
const auto refreshRate = 1e9f / config->getVsyncPeriod();
|
|
knownFrameRates.emplace_back(refreshRate);
|
|
}
|
|
|
|
// Sort and remove duplicates
|
|
const auto frameRatesEqual = [](float a, float b) { return std::abs(a - b) <= 0.01f; };
|
|
std::sort(knownFrameRates.begin(), knownFrameRates.end());
|
|
knownFrameRates.erase(std::unique(knownFrameRates.begin(), knownFrameRates.end(),
|
|
frameRatesEqual),
|
|
knownFrameRates.end());
|
|
return knownFrameRates;
|
|
}
|
|
|
|
float RefreshRateConfigs::findClosestKnownFrameRate(float frameRate) const {
|
|
if (frameRate <= *mKnownFrameRates.begin()) {
|
|
return *mKnownFrameRates.begin();
|
|
}
|
|
|
|
if (frameRate >= *std::prev(mKnownFrameRates.end())) {
|
|
return *std::prev(mKnownFrameRates.end());
|
|
}
|
|
|
|
auto lowerBound = std::lower_bound(mKnownFrameRates.begin(), mKnownFrameRates.end(), frameRate);
|
|
|
|
const auto distance1 = std::abs(frameRate - *lowerBound);
|
|
const auto distance2 = std::abs(frameRate - *std::prev(lowerBound));
|
|
return distance1 < distance2 ? *lowerBound : *std::prev(lowerBound);
|
|
}
|
|
|
|
RefreshRateConfigs::KernelIdleTimerAction RefreshRateConfigs::getIdleTimerAction() const {
|
|
std::lock_guard lock(mLock);
|
|
const auto& deviceMin = getMinRefreshRate();
|
|
const auto& minByPolicy = getMinRefreshRateByPolicyLocked();
|
|
const auto& maxByPolicy = getMaxRefreshRateByPolicyLocked();
|
|
|
|
// Kernel idle timer will set the refresh rate to the device min. If DisplayManager says that
|
|
// the min allowed refresh rate is higher than the device min, we do not want to enable the
|
|
// timer.
|
|
if (deviceMin < minByPolicy) {
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOff;
|
|
}
|
|
if (minByPolicy == maxByPolicy) {
|
|
// Do not sent the call to toggle off kernel idle timer if the device min and policy min and
|
|
// max are all the same. This saves us extra unnecessary calls to sysprop.
|
|
if (deviceMin == minByPolicy) {
|
|
return RefreshRateConfigs::KernelIdleTimerAction::NoChange;
|
|
}
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOff;
|
|
}
|
|
// Turn on the timer in all other cases.
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOn;
|
|
}
|
|
|
|
} // namespace android::scheduler
|