You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
978 lines
40 KiB
978 lines
40 KiB
/*
|
|
* 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
|
|
|
|
// TODO(b/129481165): remove the #pragma below and fix conversion issues
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wextra"
|
|
|
|
#include "RefreshRateConfigs.h"
|
|
#include <android-base/stringprintf.h>
|
|
#include <utils/Trace.h>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include "../SurfaceFlingerProperties.h"
|
|
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "RefreshRateConfigs"
|
|
|
|
namespace android::scheduler {
|
|
namespace {
|
|
std::string formatLayerInfo(const RefreshRateConfigs::LayerRequirement& layer, float weight) {
|
|
return base::StringPrintf("%s (type=%s, weight=%.2f seamlessness=%s) %s", layer.name.c_str(),
|
|
RefreshRateConfigs::layerVoteTypeString(layer.vote).c_str(), weight,
|
|
toString(layer.seamlessness).c_str(),
|
|
to_string(layer.desiredRefreshRate).c_str());
|
|
}
|
|
|
|
std::vector<Fps> constructKnownFrameRates(const DisplayModes& modes) {
|
|
std::vector<Fps> knownFrameRates = {Fps(24.0f), Fps(30.0f), Fps(45.0f), Fps(60.0f), Fps(72.0f)};
|
|
knownFrameRates.reserve(knownFrameRates.size() + modes.size());
|
|
|
|
// Add all supported refresh rates to the set
|
|
for (const auto& mode : modes) {
|
|
const auto refreshRate = Fps::fromPeriodNsecs(mode->getVsyncPeriod());
|
|
knownFrameRates.emplace_back(refreshRate);
|
|
}
|
|
|
|
// Sort and remove duplicates
|
|
std::sort(knownFrameRates.begin(), knownFrameRates.end(), Fps::comparesLess);
|
|
knownFrameRates.erase(std::unique(knownFrameRates.begin(), knownFrameRates.end(),
|
|
Fps::EqualsWithMargin()),
|
|
knownFrameRates.end());
|
|
return knownFrameRates;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
using AllRefreshRatesMapType = RefreshRateConfigs::AllRefreshRatesMapType;
|
|
using RefreshRate = RefreshRateConfigs::RefreshRate;
|
|
|
|
std::string RefreshRate::toString() const {
|
|
return base::StringPrintf("{id=%d, hwcId=%d, fps=%.2f, width=%d, height=%d group=%d}",
|
|
getModeId().value(), mode->getHwcId(), getFps().getValue(),
|
|
mode->getWidth(), mode->getHeight(), getModeGroup());
|
|
}
|
|
|
|
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";
|
|
case LayerVoteType::ExplicitExact:
|
|
return "ExplicitExact";
|
|
}
|
|
}
|
|
|
|
std::string RefreshRateConfigs::Policy::toString() const {
|
|
return base::StringPrintf("default mode ID: %d, allowGroupSwitching = %d"
|
|
", primary range: %s, app request range: %s",
|
|
defaultMode.value(), allowGroupSwitching,
|
|
primaryRange.toString().c_str(), appRequestRange.toString().c_str());
|
|
}
|
|
|
|
std::pair<nsecs_t, nsecs_t> RefreshRateConfigs::getDisplayFrames(nsecs_t layerPeriod,
|
|
nsecs_t displayPeriod) const {
|
|
auto [quotient, remainder] = std::div(layerPeriod, displayPeriod);
|
|
if (remainder <= MARGIN_FOR_PERIOD_CALCULATION ||
|
|
std::abs(remainder - displayPeriod) <= MARGIN_FOR_PERIOD_CALCULATION) {
|
|
quotient++;
|
|
remainder = 0;
|
|
}
|
|
|
|
return {quotient, remainder};
|
|
}
|
|
|
|
bool RefreshRateConfigs::isVoteAllowed(const LayerRequirement& layer,
|
|
const RefreshRate& refreshRate) const {
|
|
switch (layer.vote) {
|
|
case LayerVoteType::ExplicitExactOrMultiple:
|
|
case LayerVoteType::Heuristic:
|
|
if (mConfig.frameRateMultipleThreshold != 0 &&
|
|
refreshRate.fps.greaterThanOrEqualWithMargin(
|
|
Fps(mConfig.frameRateMultipleThreshold)) &&
|
|
layer.desiredRefreshRate.lessThanWithMargin(
|
|
Fps(mConfig.frameRateMultipleThreshold / 2))) {
|
|
// Don't vote high refresh rates past the threshold for layers with a low desired
|
|
// refresh rate. For example, desired 24 fps with 120 Hz threshold means no vote for
|
|
// 120 Hz, but desired 60 fps should have a vote.
|
|
return false;
|
|
}
|
|
break;
|
|
case LayerVoteType::ExplicitDefault:
|
|
case LayerVoteType::ExplicitExact:
|
|
case LayerVoteType::Max:
|
|
case LayerVoteType::Min:
|
|
case LayerVoteType::NoVote:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
float RefreshRateConfigs::calculateLayerScoreLocked(const LayerRequirement& layer,
|
|
const RefreshRate& refreshRate,
|
|
bool isSeamlessSwitch) const {
|
|
if (!isVoteAllowed(layer, refreshRate)) {
|
|
return 0;
|
|
}
|
|
|
|
// Slightly prefer seamless switches.
|
|
constexpr float kSeamedSwitchPenalty = 0.95f;
|
|
const float seamlessness = isSeamlessSwitch ? 1.0f : kSeamedSwitchPenalty;
|
|
|
|
// If the layer wants Max, give higher score to the higher refresh rate
|
|
if (layer.vote == LayerVoteType::Max) {
|
|
const auto ratio =
|
|
refreshRate.fps.getValue() / mAppRequestRefreshRates.back()->fps.getValue();
|
|
// use ratio^2 to get a lower score the more we get further from peak
|
|
return ratio * ratio;
|
|
}
|
|
|
|
const auto displayPeriod = refreshRate.getVsyncPeriod();
|
|
const auto layerPeriod = layer.desiredRefreshRate.getPeriodNsecs();
|
|
if (layer.vote == LayerVoteType::ExplicitDefault) {
|
|
// 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));
|
|
}
|
|
|
|
if (layer.vote == LayerVoteType::ExplicitExactOrMultiple ||
|
|
layer.vote == LayerVoteType::Heuristic) {
|
|
// Calculate how many display vsyncs we need to present a single frame for this
|
|
// layer
|
|
const auto [displayFramesQuotient, displayFramesRemainder] =
|
|
getDisplayFrames(layerPeriod, displayPeriod);
|
|
static constexpr size_t MAX_FRAMES_TO_FIT = 10; // Stop calculating when score < 0.1
|
|
if (displayFramesRemainder == 0) {
|
|
// Layer desired refresh rate matches the display rate.
|
|
return 1.0f * seamlessness;
|
|
}
|
|
|
|
if (displayFramesQuotient == 0) {
|
|
// Layer desired refresh rate is higher than 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 than the display rate. Check how well it fits
|
|
// the cadence.
|
|
auto diff = std::abs(displayFramesRemainder - (displayPeriod - displayFramesRemainder));
|
|
int iter = 2;
|
|
while (diff > MARGIN_FOR_PERIOD_CALCULATION && iter < MAX_FRAMES_TO_FIT) {
|
|
diff = diff - (displayPeriod - diff);
|
|
iter++;
|
|
}
|
|
|
|
return (1.0f / iter) * seamlessness;
|
|
}
|
|
|
|
if (layer.vote == LayerVoteType::ExplicitExact) {
|
|
const int divider = getFrameRateDivider(refreshRate.getFps(), layer.desiredRefreshRate);
|
|
if (mSupportsFrameRateOverride) {
|
|
// Since we support frame rate override, allow refresh rates which are
|
|
// multiples of the layer's request, as those apps would be throttled
|
|
// down to run at the desired refresh rate.
|
|
return divider > 0;
|
|
}
|
|
|
|
return divider == 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct RefreshRateScore {
|
|
const RefreshRate* refreshRate;
|
|
float score;
|
|
};
|
|
|
|
RefreshRate RefreshRateConfigs::getBestRefreshRate(const std::vector<LayerRequirement>& layers,
|
|
const GlobalSignals& globalSignals,
|
|
GlobalSignals* outSignalsConsidered) const {
|
|
std::lock_guard lock(mLock);
|
|
// HUANGLONG begin
|
|
// when perfered RefreshRateType is set, we consider take it as best RefershRate,
|
|
// unless there are not fix support display mode
|
|
if (perferedRateType != RefreshRateType::REFRESH_RATE_NONE) {
|
|
const Policy* policy = getCurrentPolicyLocked();
|
|
const auto& defaultMode = mRefreshRates.at(policy->defaultMode)->mode;
|
|
for (const auto& [type, refreshRate] : mRefreshRates) {
|
|
const auto& mode = refreshRate->mode;
|
|
if (mode->getHeight() == defaultMode->getHeight() &&
|
|
mode->getWidth() == defaultMode->getWidth() &&
|
|
mode->getDpiX() == defaultMode->getDpiX() &&
|
|
mode->getDpiY() == defaultMode->getDpiY() &&
|
|
(policy->allowGroupSwitching ||
|
|
mode->getGroup() == defaultMode->getGroup()) &&
|
|
mode->getFps().getIntValue() == static_cast<int>(perferedRateType)) {
|
|
return *(refreshRate.get());
|
|
}
|
|
}
|
|
}
|
|
// HUANGLONG end
|
|
if (auto cached = getCachedBestRefreshRate(layers, globalSignals, outSignalsConsidered)) {
|
|
return *cached;
|
|
}
|
|
|
|
GlobalSignals signalsConsidered;
|
|
RefreshRate result = getBestRefreshRateLocked(layers, globalSignals, &signalsConsidered);
|
|
lastBestRefreshRateInvocation.emplace(
|
|
GetBestRefreshRateInvocation{.layerRequirements = layers,
|
|
.globalSignals = globalSignals,
|
|
.outSignalsConsidered = signalsConsidered,
|
|
.resultingBestRefreshRate = result});
|
|
if (outSignalsConsidered) {
|
|
*outSignalsConsidered = signalsConsidered;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::optional<RefreshRate> RefreshRateConfigs::getCachedBestRefreshRate(
|
|
const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
|
|
GlobalSignals* outSignalsConsidered) const {
|
|
const bool sameAsLastCall = lastBestRefreshRateInvocation &&
|
|
lastBestRefreshRateInvocation->layerRequirements == layers &&
|
|
lastBestRefreshRateInvocation->globalSignals == globalSignals;
|
|
|
|
if (sameAsLastCall) {
|
|
if (outSignalsConsidered) {
|
|
*outSignalsConsidered = lastBestRefreshRateInvocation->outSignalsConsidered;
|
|
}
|
|
return lastBestRefreshRateInvocation->resultingBestRefreshRate;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
RefreshRate RefreshRateConfigs::getBestRefreshRateLocked(
|
|
const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
|
|
GlobalSignals* outSignalsConsidered) const {
|
|
ATRACE_CALL();
|
|
ALOGV("getBestRefreshRate %zu layers", layers.size());
|
|
|
|
if (outSignalsConsidered) *outSignalsConsidered = {};
|
|
const auto setTouchConsidered = [&] {
|
|
if (outSignalsConsidered) {
|
|
outSignalsConsidered->touch = true;
|
|
}
|
|
};
|
|
|
|
const auto setIdleConsidered = [&] {
|
|
if (outSignalsConsidered) {
|
|
outSignalsConsidered->idle = true;
|
|
}
|
|
};
|
|
|
|
int noVoteLayers = 0;
|
|
int minVoteLayers = 0;
|
|
int maxVoteLayers = 0;
|
|
int explicitDefaultVoteLayers = 0;
|
|
int explicitExactOrMultipleVoteLayers = 0;
|
|
int explicitExact = 0;
|
|
float maxExplicitWeight = 0;
|
|
int seamedFocusedLayers = 0;
|
|
for (const auto& layer : layers) {
|
|
switch (layer.vote) {
|
|
case LayerVoteType::NoVote:
|
|
noVoteLayers++;
|
|
break;
|
|
case LayerVoteType::Min:
|
|
minVoteLayers++;
|
|
break;
|
|
case LayerVoteType::Max:
|
|
maxVoteLayers++;
|
|
break;
|
|
case LayerVoteType::ExplicitDefault:
|
|
explicitDefaultVoteLayers++;
|
|
maxExplicitWeight = std::max(maxExplicitWeight, layer.weight);
|
|
break;
|
|
case LayerVoteType::ExplicitExactOrMultiple:
|
|
explicitExactOrMultipleVoteLayers++;
|
|
maxExplicitWeight = std::max(maxExplicitWeight, layer.weight);
|
|
break;
|
|
case LayerVoteType::ExplicitExact:
|
|
explicitExact++;
|
|
maxExplicitWeight = std::max(maxExplicitWeight, layer.weight);
|
|
break;
|
|
case LayerVoteType::Heuristic:
|
|
break;
|
|
}
|
|
|
|
if (layer.seamlessness == Seamlessness::SeamedAndSeamless && layer.focused) {
|
|
seamedFocusedLayers++;
|
|
}
|
|
}
|
|
|
|
const bool hasExplicitVoteLayers = explicitDefaultVoteLayers > 0 ||
|
|
explicitExactOrMultipleVoteLayers > 0 || explicitExact > 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.equalsWithMargin(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<RefreshRateScore> scores;
|
|
scores.reserve(mAppRequestRefreshRates.size());
|
|
|
|
for (const auto refreshRate : mAppRequestRefreshRates) {
|
|
scores.emplace_back(RefreshRateScore{refreshRate, 0.0f});
|
|
}
|
|
|
|
const auto& defaultMode = mRefreshRates.at(policy->defaultMode);
|
|
|
|
for (const auto& layer : layers) {
|
|
ALOGV("Calculating score for %s (%s, weight %.2f, desired %.2f) ", layer.name.c_str(),
|
|
layerVoteTypeString(layer.vote).c_str(), layer.weight,
|
|
layer.desiredRefreshRate.getValue());
|
|
if (layer.vote == LayerVoteType::NoVote || layer.vote == LayerVoteType::Min) {
|
|
continue;
|
|
}
|
|
|
|
auto weight = layer.weight;
|
|
|
|
for (auto i = 0u; i < scores.size(); i++) {
|
|
const bool isSeamlessSwitch =
|
|
scores[i].refreshRate->getModeGroup() == mCurrentRefreshRate->getModeGroup();
|
|
|
|
if (layer.seamlessness == Seamlessness::OnlySeamless && !isSeamlessSwitch) {
|
|
ALOGV("%s ignores %s to avoid non-seamless switch. Current mode = %s",
|
|
formatLayerInfo(layer, weight).c_str(),
|
|
scores[i].refreshRate->toString().c_str(),
|
|
mCurrentRefreshRate->toString().c_str());
|
|
continue;
|
|
}
|
|
|
|
if (layer.seamlessness == Seamlessness::SeamedAndSeamless && !isSeamlessSwitch &&
|
|
!layer.focused) {
|
|
ALOGV("%s ignores %s because it's not focused and the switch is going to be seamed."
|
|
" Current mode = %s",
|
|
formatLayerInfo(layer, weight).c_str(),
|
|
scores[i].refreshRate->toString().c_str(),
|
|
mCurrentRefreshRate->toString().c_str());
|
|
continue;
|
|
}
|
|
|
|
// Layers with default seamlessness vote for the current mode group if
|
|
// there are layers with seamlessness=SeamedAndSeamless and for the default
|
|
// mode group otherwise. In second case, if the current mode group is different
|
|
// from the default, this means a layer with seamlessness=SeamedAndSeamless has just
|
|
// disappeared.
|
|
const bool isInPolicyForDefault = seamedFocusedLayers > 0
|
|
? scores[i].refreshRate->getModeGroup() == mCurrentRefreshRate->getModeGroup()
|
|
: scores[i].refreshRate->getModeGroup() == defaultMode->getModeGroup();
|
|
|
|
if (layer.seamlessness == Seamlessness::Default && !isInPolicyForDefault) {
|
|
ALOGV("%s ignores %s. Current mode = %s", formatLayerInfo(layer, weight).c_str(),
|
|
scores[i].refreshRate->toString().c_str(),
|
|
mCurrentRefreshRate->toString().c_str());
|
|
continue;
|
|
}
|
|
|
|
bool inPrimaryRange = scores[i].refreshRate->inPolicy(policy->primaryRange.min,
|
|
policy->primaryRange.max);
|
|
if ((primaryRangeIsSingleRate || !inPrimaryRange) &&
|
|
!(layer.focused &&
|
|
(layer.vote == LayerVoteType::ExplicitDefault ||
|
|
layer.vote == LayerVoteType::ExplicitExact))) {
|
|
// Only focused layers with ExplicitDefault frame rate settings are allowed to score
|
|
// refresh rates outside the primary range.
|
|
continue;
|
|
}
|
|
|
|
const auto layerScore =
|
|
calculateLayerScoreLocked(layer, *scores[i].refreshRate, isSeamlessSwitch);
|
|
ALOGV("%s gives %s score of %.2f", formatLayerInfo(layer, weight).c_str(),
|
|
scores[i].refreshRate->getName().c_str(), layerScore);
|
|
scores[i].score += weight * layerScore;
|
|
}
|
|
}
|
|
|
|
// 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(),
|
|
[](RefreshRateScore score) { return score.score == 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();
|
|
|
|
const bool touchBoostForExplicitExact = [&] {
|
|
if (mSupportsFrameRateOverride) {
|
|
// Enable touch boost if there are other layers besides exact
|
|
return explicitExact + noVoteLayers != layers.size();
|
|
} else {
|
|
// Enable touch boost if there are no exact layers
|
|
return explicitExact == 0;
|
|
}
|
|
}();
|
|
if (globalSignals.touch && explicitDefaultVoteLayers == 0 && touchBoostForExplicitExact &&
|
|
bestRefreshRate->fps.lessThanWithMargin(touchRefreshRate.fps)) {
|
|
setTouchConsidered();
|
|
ALOGV("TouchBoost - choose %s", touchRefreshRate.getName().c_str());
|
|
return touchRefreshRate;
|
|
}
|
|
|
|
return *bestRefreshRate;
|
|
}
|
|
|
|
std::unordered_map<uid_t, std::vector<const RefreshRateConfigs::LayerRequirement*>>
|
|
groupLayersByUid(const std::vector<RefreshRateConfigs::LayerRequirement>& layers) {
|
|
std::unordered_map<uid_t, std::vector<const RefreshRateConfigs::LayerRequirement*>> layersByUid;
|
|
for (const auto& layer : layers) {
|
|
auto iter = layersByUid.emplace(layer.ownerUid,
|
|
std::vector<const RefreshRateConfigs::LayerRequirement*>());
|
|
auto& layersWithSameUid = iter.first->second;
|
|
layersWithSameUid.push_back(&layer);
|
|
}
|
|
|
|
// Remove uids that can't have a frame rate override
|
|
for (auto iter = layersByUid.begin(); iter != layersByUid.end();) {
|
|
const auto& layersWithSameUid = iter->second;
|
|
bool skipUid = false;
|
|
for (const auto& layer : layersWithSameUid) {
|
|
if (layer->vote == RefreshRateConfigs::LayerVoteType::Max ||
|
|
layer->vote == RefreshRateConfigs::LayerVoteType::Heuristic) {
|
|
skipUid = true;
|
|
break;
|
|
}
|
|
}
|
|
if (skipUid) {
|
|
iter = layersByUid.erase(iter);
|
|
} else {
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
return layersByUid;
|
|
}
|
|
|
|
std::vector<RefreshRateScore> initializeScoresForAllRefreshRates(
|
|
const AllRefreshRatesMapType& refreshRates) {
|
|
std::vector<RefreshRateScore> scores;
|
|
scores.reserve(refreshRates.size());
|
|
for (const auto& [ignored, refreshRate] : refreshRates) {
|
|
scores.emplace_back(RefreshRateScore{refreshRate.get(), 0.0f});
|
|
}
|
|
std::sort(scores.begin(), scores.end(),
|
|
[](const auto& a, const auto& b) { return *a.refreshRate < *b.refreshRate; });
|
|
return scores;
|
|
}
|
|
|
|
RefreshRateConfigs::UidToFrameRateOverride RefreshRateConfigs::getFrameRateOverrides(
|
|
const std::vector<LayerRequirement>& layers, Fps displayFrameRate, bool touch) const {
|
|
ATRACE_CALL();
|
|
if (!mSupportsFrameRateOverride) return {};
|
|
|
|
ALOGV("getFrameRateOverrides %zu layers", layers.size());
|
|
std::lock_guard lock(mLock);
|
|
std::vector<RefreshRateScore> scores = initializeScoresForAllRefreshRates(mRefreshRates);
|
|
std::unordered_map<uid_t, std::vector<const LayerRequirement*>> layersByUid =
|
|
groupLayersByUid(layers);
|
|
UidToFrameRateOverride frameRateOverrides;
|
|
for (const auto& [uid, layersWithSameUid] : layersByUid) {
|
|
// Layers with ExplicitExactOrMultiple expect touch boost
|
|
const bool hasExplicitExactOrMultiple =
|
|
std::any_of(layersWithSameUid.cbegin(), layersWithSameUid.cend(),
|
|
[](const auto& layer) {
|
|
return layer->vote == LayerVoteType::ExplicitExactOrMultiple;
|
|
});
|
|
|
|
if (touch && hasExplicitExactOrMultiple) {
|
|
continue;
|
|
}
|
|
|
|
for (auto& score : scores) {
|
|
score.score = 0;
|
|
}
|
|
|
|
for (const auto& layer : layersWithSameUid) {
|
|
if (layer->vote == LayerVoteType::NoVote || layer->vote == LayerVoteType::Min) {
|
|
continue;
|
|
}
|
|
|
|
LOG_ALWAYS_FATAL_IF(layer->vote != LayerVoteType::ExplicitDefault &&
|
|
layer->vote != LayerVoteType::ExplicitExactOrMultiple &&
|
|
layer->vote != LayerVoteType::ExplicitExact);
|
|
for (RefreshRateScore& score : scores) {
|
|
const auto layerScore = calculateLayerScoreLocked(*layer, *score.refreshRate,
|
|
/*isSeamlessSwitch*/ true);
|
|
score.score += layer->weight * layerScore;
|
|
}
|
|
}
|
|
|
|
// We just care about the refresh rates which are a divider of the
|
|
// display refresh rate
|
|
auto iter =
|
|
std::remove_if(scores.begin(), scores.end(), [&](const RefreshRateScore& score) {
|
|
return getFrameRateDivider(displayFrameRate, score.refreshRate->getFps()) == 0;
|
|
});
|
|
scores.erase(iter, scores.end());
|
|
|
|
// If we never scored any layers, we don't have a preferred frame rate
|
|
if (std::all_of(scores.begin(), scores.end(),
|
|
[](const RefreshRateScore& score) { return score.score == 0; })) {
|
|
continue;
|
|
}
|
|
|
|
// Now that we scored all the refresh rates we need to pick the one that got the highest
|
|
// score.
|
|
const RefreshRate* bestRefreshRate = getBestRefreshRate(scores.begin(), scores.end());
|
|
frameRateOverrides.emplace(uid, bestRefreshRate->getFps());
|
|
}
|
|
|
|
return frameRateOverrides;
|
|
}
|
|
|
|
template <typename Iter>
|
|
const RefreshRate* RefreshRateConfigs::getBestRefreshRate(Iter begin, Iter end) const {
|
|
constexpr auto EPSILON = 0.001f;
|
|
const RefreshRate* bestRefreshRate = begin->refreshRate;
|
|
float max = begin->score;
|
|
for (auto i = begin; i != end; ++i) {
|
|
const auto [refreshRate, score] = *i;
|
|
ALOGV("%s scores %.2f", refreshRate->getName().c_str(), score);
|
|
|
|
ATRACE_INT(refreshRate->getName().c_str(), round<int>(score * 100));
|
|
|
|
if (score > max * (1 + EPSILON)) {
|
|
max = score;
|
|
bestRefreshRate = refreshRate;
|
|
}
|
|
}
|
|
|
|
return bestRefreshRate;
|
|
}
|
|
|
|
std::optional<Fps> RefreshRateConfigs::onKernelTimerChanged(
|
|
std::optional<DisplayModeId> desiredActiveConfigId, bool timerExpired) const {
|
|
std::lock_guard lock(mLock);
|
|
|
|
const auto& current = desiredActiveConfigId ? *mRefreshRates.at(*desiredActiveConfigId)
|
|
: *mCurrentRefreshRate;
|
|
const auto& min = *mMinSupportedRefreshRate;
|
|
|
|
if (current != min) {
|
|
const auto& refreshRate = timerExpired ? min : current;
|
|
return refreshRate.getFps();
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMinRefreshRateByPolicyLocked() const {
|
|
for (auto refreshRate : mPrimaryRefreshRates) {
|
|
if (mCurrentRefreshRate->getModeGroup() == refreshRate->getModeGroup()) {
|
|
return *refreshRate;
|
|
}
|
|
}
|
|
ALOGE("Can't find min refresh rate by policy with the same mode group"
|
|
" as the current mode %s",
|
|
mCurrentRefreshRate->toString().c_str());
|
|
// Defaulting to the lowest refresh rate
|
|
return *mPrimaryRefreshRates.front();
|
|
}
|
|
|
|
RefreshRate RefreshRateConfigs::getMaxRefreshRateByPolicy() const {
|
|
std::lock_guard lock(mLock);
|
|
return getMaxRefreshRateByPolicyLocked();
|
|
}
|
|
|
|
const RefreshRate& RefreshRateConfigs::getMaxRefreshRateByPolicyLocked() const {
|
|
for (auto it = mPrimaryRefreshRates.rbegin(); it != mPrimaryRefreshRates.rend(); it++) {
|
|
const auto& refreshRate = (**it);
|
|
if (mCurrentRefreshRate->getModeGroup() == refreshRate.getModeGroup()) {
|
|
return refreshRate;
|
|
}
|
|
}
|
|
ALOGE("Can't find max refresh rate by policy with the same mode group"
|
|
" as the current mode %s",
|
|
mCurrentRefreshRate->toString().c_str());
|
|
// Defaulting to the highest refresh rate
|
|
return *mPrimaryRefreshRates.back();
|
|
}
|
|
|
|
RefreshRate RefreshRateConfigs::getCurrentRefreshRate() const {
|
|
std::lock_guard lock(mLock);
|
|
return *mCurrentRefreshRate;
|
|
}
|
|
|
|
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()->defaultMode);
|
|
}
|
|
|
|
void RefreshRateConfigs::setCurrentModeId(DisplayModeId modeId) {
|
|
std::lock_guard lock(mLock);
|
|
|
|
// Invalidate the cached invocation to getBestRefreshRate. This forces
|
|
// the refresh rate to be recomputed on the next call to getBestRefreshRate.
|
|
lastBestRefreshRateInvocation.reset();
|
|
|
|
mCurrentRefreshRate = mRefreshRates.at(modeId).get();
|
|
}
|
|
|
|
RefreshRateConfigs::RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,
|
|
Config config)
|
|
: mKnownFrameRates(constructKnownFrameRates(modes)), mConfig(config) {
|
|
updateDisplayModes(modes, currentModeId);
|
|
}
|
|
|
|
void RefreshRateConfigs::updateDisplayModes(const DisplayModes& modes,
|
|
DisplayModeId currentModeId) {
|
|
std::lock_guard lock(mLock);
|
|
|
|
// The current mode should be supported
|
|
LOG_ALWAYS_FATAL_IF(std::none_of(modes.begin(), modes.end(), [&](DisplayModePtr mode) {
|
|
return mode->getId() == currentModeId;
|
|
}));
|
|
|
|
// Invalidate the cached invocation to getBestRefreshRate. This forces
|
|
// the refresh rate to be recomputed on the next call to getBestRefreshRate.
|
|
lastBestRefreshRateInvocation.reset();
|
|
|
|
mRefreshRates.clear();
|
|
for (const auto& mode : modes) {
|
|
const auto modeId = mode->getId();
|
|
mRefreshRates.emplace(modeId,
|
|
std::make_unique<RefreshRate>(modeId, mode, mode->getFps(),
|
|
RefreshRate::ConstructorTag(0)));
|
|
if (modeId == currentModeId) {
|
|
mCurrentRefreshRate = mRefreshRates.at(modeId).get();
|
|
}
|
|
}
|
|
|
|
std::vector<const RefreshRate*> sortedModes;
|
|
getSortedRefreshRateListLocked([](const RefreshRate&) { return true; }, &sortedModes);
|
|
// Reset the policy because the old one may no longer be valid.
|
|
mDisplayManagerPolicy = {};
|
|
mDisplayManagerPolicy.defaultMode = currentModeId;
|
|
mMinSupportedRefreshRate = sortedModes.front();
|
|
mMaxSupportedRefreshRate = sortedModes.back();
|
|
|
|
mSupportsFrameRateOverride = false;
|
|
if (mConfig.enableFrameRateOverride) {
|
|
for (const auto& mode1 : sortedModes) {
|
|
for (const auto& mode2 : sortedModes) {
|
|
if (getFrameRateDivider(mode1->getFps(), mode2->getFps()) >= 2) {
|
|
mSupportsFrameRateOverride = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
constructAvailableRefreshRates();
|
|
}
|
|
|
|
bool RefreshRateConfigs::isPolicyValidLocked(const Policy& policy) const {
|
|
// defaultMode must be a valid mode, and within the given refresh rate range.
|
|
auto iter = mRefreshRates.find(policy.defaultMode);
|
|
if (iter == mRefreshRates.end()) {
|
|
ALOGE("Default mode is not found.");
|
|
return false;
|
|
}
|
|
const RefreshRate& refreshRate = *iter->second;
|
|
if (!refreshRate.inPolicy(policy.primaryRange.min, policy.primaryRange.max)) {
|
|
ALOGE("Default mode is not in the primary range.");
|
|
return false;
|
|
}
|
|
return policy.appRequestRange.min.lessThanOrEqualWithMargin(policy.primaryRange.min) &&
|
|
policy.appRequestRange.max.greaterThanOrEqualWithMargin(policy.primaryRange.max);
|
|
}
|
|
|
|
status_t RefreshRateConfigs::setDisplayManagerPolicy(const Policy& policy) {
|
|
std::lock_guard lock(mLock);
|
|
if (!isPolicyValidLocked(policy)) {
|
|
ALOGE("Invalid refresh rate policy: %s", policy.toString().c_str());
|
|
return BAD_VALUE;
|
|
}
|
|
lastBestRefreshRateInvocation.reset();
|
|
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 && !isPolicyValidLocked(*policy)) {
|
|
return BAD_VALUE;
|
|
}
|
|
lastBestRefreshRateInvocation.reset();
|
|
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::isModeAllowed(DisplayModeId modeId) const {
|
|
std::lock_guard lock(mLock);
|
|
for (const RefreshRate* refreshRate : mAppRequestRefreshRates) {
|
|
if (refreshRate->modeId == modeId) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void RefreshRateConfigs::getSortedRefreshRateListLocked(
|
|
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("getSortedRefreshRateListLocked: mode %d added to list policy",
|
|
refreshRate->modeId.value());
|
|
outRefreshRates->push_back(refreshRate.get());
|
|
}
|
|
}
|
|
|
|
std::sort(outRefreshRates->begin(), outRefreshRates->end(),
|
|
[](const auto refreshRate1, const auto refreshRate2) {
|
|
if (refreshRate1->mode->getVsyncPeriod() !=
|
|
refreshRate2->mode->getVsyncPeriod()) {
|
|
return refreshRate1->mode->getVsyncPeriod() >
|
|
refreshRate2->mode->getVsyncPeriod();
|
|
} else {
|
|
return refreshRate1->mode->getGroup() > refreshRate2->mode->getGroup();
|
|
}
|
|
});
|
|
}
|
|
|
|
void RefreshRateConfigs::constructAvailableRefreshRates() {
|
|
// Filter modes based on current policy and sort based on vsync period
|
|
const Policy* policy = getCurrentPolicyLocked();
|
|
const auto& defaultMode = mRefreshRates.at(policy->defaultMode)->mode;
|
|
ALOGV("constructAvailableRefreshRates: %s ", policy->toString().c_str());
|
|
|
|
auto filterRefreshRates =
|
|
[&](Fps min, Fps max, const char* listName,
|
|
std::vector<const RefreshRate*>* outRefreshRates) REQUIRES(mLock) {
|
|
getSortedRefreshRateListLocked(
|
|
[&](const RefreshRate& refreshRate) REQUIRES(mLock) {
|
|
const auto& mode = refreshRate.mode;
|
|
|
|
return mode->getHeight() == defaultMode->getHeight() &&
|
|
mode->getWidth() == defaultMode->getWidth() &&
|
|
mode->getDpiX() == defaultMode->getDpiX() &&
|
|
mode->getDpiY() == defaultMode->getDpiY() &&
|
|
(policy->allowGroupSwitching ||
|
|
mode->getGroup() == defaultMode->getGroup()) &&
|
|
refreshRate.inPolicy(min, max);
|
|
},
|
|
outRefreshRates);
|
|
|
|
LOG_ALWAYS_FATAL_IF(outRefreshRates->empty(),
|
|
"No matching modes for %s range: min=%s max=%s", listName,
|
|
to_string(min).c_str(), to_string(max).c_str());
|
|
auto stringifyRefreshRates = [&]() -> std::string {
|
|
std::string str;
|
|
for (auto refreshRate : *outRefreshRates) {
|
|
base::StringAppendF(&str, "%s ", refreshRate->getName().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);
|
|
}
|
|
|
|
Fps RefreshRateConfigs::findClosestKnownFrameRate(Fps frameRate) const {
|
|
if (frameRate.lessThanOrEqualWithMargin(*mKnownFrameRates.begin())) {
|
|
return *mKnownFrameRates.begin();
|
|
}
|
|
|
|
if (frameRate.greaterThanOrEqualWithMargin(*std::prev(mKnownFrameRates.end()))) {
|
|
return *std::prev(mKnownFrameRates.end());
|
|
}
|
|
|
|
auto lowerBound = std::lower_bound(mKnownFrameRates.begin(), mKnownFrameRates.end(), frameRate,
|
|
Fps::comparesLess);
|
|
|
|
const auto distance1 = std::abs((frameRate.getValue() - lowerBound->getValue()));
|
|
const auto distance2 = std::abs((frameRate.getValue() - std::prev(lowerBound)->getValue()));
|
|
return distance1 < distance2 ? *lowerBound : *std::prev(lowerBound);
|
|
}
|
|
|
|
RefreshRateConfigs::KernelIdleTimerAction RefreshRateConfigs::getIdleTimerAction() const {
|
|
std::lock_guard lock(mLock);
|
|
const auto& deviceMin = *mMinSupportedRefreshRate;
|
|
const auto& minByPolicy = getMinRefreshRateByPolicyLocked();
|
|
const auto& maxByPolicy = getMaxRefreshRateByPolicyLocked();
|
|
const auto& currentPolicy = getCurrentPolicyLocked();
|
|
|
|
// 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) {
|
|
// when min primary range in display manager policy is below device min turn on the timer.
|
|
if (currentPolicy->primaryRange.min.lessThanWithMargin(deviceMin.getFps())) {
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOn;
|
|
}
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOff;
|
|
}
|
|
// Turn on the timer in all other cases.
|
|
return RefreshRateConfigs::KernelIdleTimerAction::TurnOn;
|
|
}
|
|
|
|
int RefreshRateConfigs::getFrameRateDivider(Fps displayFrameRate, Fps layerFrameRate) {
|
|
// This calculation needs to be in sync with the java code
|
|
// in DisplayManagerService.getDisplayInfoForFrameRateOverride
|
|
constexpr float kThreshold = 0.1f;
|
|
const auto numPeriods = displayFrameRate.getValue() / layerFrameRate.getValue();
|
|
const auto numPeriodsRounded = std::round(numPeriods);
|
|
if (std::abs(numPeriods - numPeriodsRounded) > kThreshold) {
|
|
return 0;
|
|
}
|
|
|
|
return static_cast<int>(numPeriodsRounded);
|
|
}
|
|
|
|
void RefreshRateConfigs::dump(std::string& result) const {
|
|
std::lock_guard lock(mLock);
|
|
base::StringAppendF(&result, "DesiredDisplayModeSpecs (DisplayManager): %s\n\n",
|
|
mDisplayManagerPolicy.toString().c_str());
|
|
scheduler::RefreshRateConfigs::Policy currentPolicy = *getCurrentPolicyLocked();
|
|
if (mOverridePolicy && currentPolicy != mDisplayManagerPolicy) {
|
|
base::StringAppendF(&result, "DesiredDisplayModeSpecs (Override): %s\n\n",
|
|
currentPolicy.toString().c_str());
|
|
}
|
|
|
|
auto mode = mCurrentRefreshRate->mode;
|
|
base::StringAppendF(&result, "Current mode: %s\n", mCurrentRefreshRate->toString().c_str());
|
|
|
|
result.append("Refresh rates:\n");
|
|
for (const auto& [id, refreshRate] : mRefreshRates) {
|
|
mode = refreshRate->mode;
|
|
base::StringAppendF(&result, "\t%s\n", refreshRate->toString().c_str());
|
|
}
|
|
|
|
base::StringAppendF(&result, "Supports Frame Rate Override: %s\n",
|
|
mSupportsFrameRateOverride ? "yes" : "no");
|
|
result.append("\n");
|
|
}
|
|
|
|
// HUANGLONG begin
|
|
// set perfered RefreshRateType
|
|
void RefreshRateConfigs::setPerferedRateType(RefreshRateType rateType) {
|
|
perferedRateType = rateType;
|
|
}
|
|
// HUANGLONG end
|
|
|
|
} // namespace android::scheduler
|
|
|
|
// TODO(b/129481165): remove the #pragma below and fix conversion issues
|
|
#pragma clang diagnostic pop // ignored "-Wextra"
|