Android UI架构(十二)--App请求切换帧率(3)之SurfaceFlinger计算最佳帧率.md

最新推荐文章于 2024-05-05 23:10:55 发布
最新推荐文章于 2024-05-05 23:10:55 发布
阅读量2.9k 收藏 19
点赞数 1
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014535072/article/details/108722620
版权

文章目录

参考资料

以下分析基于Android R.

简述

上一章我们分析了App是如何通过更改一个小小的WindowManager的LayoutParam的属性，来影响Framework决策帧率变化的。

接来下我们详细看看SurfaceFlinger是如何根据Framework传入的帧率参数选择合适帧率的。

一. SurfaceFlinger接受帧率变化

接上一章，从 SurfaceFlinger::setAllowedDisplayConfigs 开始. 但是Android R上入口函数些许变化：

由SurfaceControl.setAllowedDisplayConfigs(getDisplayTokenLocked(), allowedPhysIndexes)

=》SurfaceControl.setDesiredDisplayConfigSpecs(displayToken, configSpecs);

这里的configSpecs是DesiredDisplayConfigSpecs类型

1.1 SurfaceControl.setDesiredDisplayConfigSpecs

public static boolean setDesiredDisplayConfigSpecs(IBinder displayToken,
        SurfaceControl.DesiredDisplayConfigSpecs desiredDisplayConfigSpecs) {
    if (displayToken == null) {
        throw new IllegalArgumentException("displayToken must not be null");
    }

    return nativeSetDesiredDisplayConfigSpecs(displayToken, desiredDisplayConfigSpecs);
}

1.1.1 android_view_SurfaceControl.nativeSetDesiredDisplayConfigSpecs

static jboolean nativeSetDesiredDisplayConfigSpecs(JNIEnv* env, jclass clazz, jobject tokenObj,
                                                   jobject desiredDisplayConfigSpecs) {
    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
    if (token == nullptr) return JNI_FALSE;

    jint defaultConfig = env->GetIntField(desiredDisplayConfigSpecs,
                                          gDesiredDisplayConfigSpecsClassInfo.defaultConfig);
    jfloat primaryRefreshRateMin =
            env->GetFloatField(desiredDisplayConfigSpecs,
                               gDesiredDisplayConfigSpecsClassInfo.primaryRefreshRateMin);
    jfloat primaryRefreshRateMax =
            env->GetFloatField(desiredDisplayConfigSpecs,
                               gDesiredDisplayConfigSpecsClassInfo.primaryRefreshRateMax);
    jfloat appRequestRefreshRateMin =
            env->GetFloatField(desiredDisplayConfigSpecs,
                               gDesiredDisplayConfigSpecsClassInfo.appRequestRefreshRateMin);
    jfloat appRequestRefreshRateMax =
            env->GetFloatField(desiredDisplayConfigSpecs,
                               gDesiredDisplayConfigSpecsClassInfo.appRequestRefreshRateMax);

    size_t result = SurfaceComposerClient::setDesiredDisplayConfigSpecs(token, defaultConfig,
                                                                        primaryRefreshRateMin,
                                                                        primaryRefreshRateMax,
                                                                        appRequestRefreshRateMin,
                                                                        appRequestRefreshRateMax);
    return result == NO_ERROR ? JNI_TRUE : JNI_FALSE;
}

1.1.2 SurfaceComposerClient.setDesiredDisplayConfigSpecs

status_t SurfaceComposerClient::setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
                                                             int32_t defaultConfig,
                                                             float primaryRefreshRateMin,
                                                             float primaryRefreshRateMax,
                                                             float appRequestRefreshRateMin,
                                                             float appRequestRefreshRateMax) {
    // 转到SurfaceFlinger
    return ComposerService::getComposerService()
            ->setDesiredDisplayConfigSpecs(displayToken, defaultConfig, primaryRefreshRateMin,
                                           primaryRefreshRateMax, appRequestRefreshRateMin,
                                           appRequestRefreshRateMax);
}

1.2 SurfaceFlinger.setDesiredDisplayConfigSpecs

status_t SurfaceFlinger::setDesiredDisplayConfigSpecs(const sp<IBinder>& displayToken,
                                                      int32_t defaultConfig,
                                                      float primaryRefreshRateMin,
                                                      float primaryRefreshRateMax,
                                                      float appRequestRefreshRateMin,
                                                      float appRequestRefreshRateMax) {
    ATRACE_CALL();

    if (!displayToken) {
        return BAD_VALUE;
    }

    // Lambda表达式
    auto future = schedule([=]() -> status_t {
        const auto display = getDisplayDeviceLocked(displayToken);
        if (!display) {
            ALOGE("Attempt to set desired display configs for invalid display token %p",
                  displayToken.get());
            return NAME_NOT_FOUND;
        } else if (display->isVirtual()) {
            ALOGW("Attempt to set desired display configs for virtual display");
            return INVALID_OPERATION;
        } else {
            using Policy = scheduler::RefreshRateConfigs::Policy;
            // 初始化policy
            const Policy policy{HwcConfigIndexType(defaultConfig),
                                {primaryRefreshRateMin, primaryRefreshRateMax},
                                {appRequestRefreshRateMin, appRequestRefreshRateMax}};
            constexpr bool kOverridePolicy = false;

            return setDesiredDisplayConfigSpecsInternal(display, policy, kOverridePolicy);
        }
    });

    return future.get();
}

1.2.1 SurfaceFlinger.schedule

template <typename F, typename T>
inline std::future<T> SurfaceFlinger::schedule(F&& f) {
    auto [task, future] = makeTask(std::move(f));
    mEventQueue->postMessage(std::move(task));
    return std::move(future);
}

//  MessageQueue.h
template <typename F>
inline auto makeTask(F&& f) {
    sp<Task<F>> task = new Task<F>(std::move(f));
    return std::make_pair(task, task->mTask.get_future());
}
//  MessageQueue.h
template <typename F>
class Task : public MessageHandler {
    template <typename G>
    friend auto makeTask(G&&);

    explicit Task(F&& f) : mTask(std::move(f)) {}

    void handleMessage(const Message&) override { mTask(); }

    using T = std::invoke_result_t<F>;
    std::packaged_task<T()> mTask;
};

1.3 SurfaceFlinger.setDesiredDisplayConfigSpecsInternal

status_t SurfaceFlinger::setDesiredDisplayConfigSpecsInternal(
        const sp<DisplayDevice>& display,
        const std::optional<scheduler::RefreshRateConfigs::Policy>& policy, bool overridePolicy) {
    Mutex::Autolock lock(mStateLock);
    ......
    // overridePolicy 一般都是false
    status_t setPolicyResult = overridePolicy
            ? mRefreshRateConfigs->setOverridePolicy(policy)
            // 1.3.1 更改当前帧率策略
            : mRefreshRateConfigs->setDisplayManagerPolicy(*policy);
    if (setPolicyResult < 0) {
        return BAD_VALUE;
    }
    if (setPolicyResult == scheduler::RefreshRateConfigs::CURRENT_POLICY_UNCHANGED) {
        return NO_ERROR;
    }
    scheduler::RefreshRateConfigs::Policy currentPolicy = mRefreshRateConfigs->getCurrentPolicy();

    ALOGV("Setting desired display config specs: defaultConfig: %d primaryRange: [%.0f %.0f]"
          " expandedRange: [%.0f %.0f]",
          currentPolicy.defaultConfig.value(), currentPolicy.primaryRange.min,
          currentPolicy.primaryRange.max, currentPolicy.appRequestRange.min,
          currentPolicy.appRequestRange.max);

    // TODO(b/140204874): Leave the event in until we do proper testing with all apps that might
    // be depending in this callback.
    const nsecs_t vsyncPeriod =
            mRefreshRateConfigs->getRefreshRateFromConfigId(display->getActiveConfig())
                    .getVsyncPeriod();
    mScheduler->onPrimaryDisplayConfigChanged(mAppConnectionHandle, display->getId()->value,
                                              display->getActiveConfig(), vsyncPeriod);
    toggleKernelIdleTimer();

    // 1.3.3 获取configId
    auto configId = mScheduler->getPreferredConfigId();
    // configId是std::optional<HwcConfigIndexType>类型的，这里判断是否存在值，一般存在
    // 根据HwcConfigIndexType获取实际的 RefreshRate 参数
    auto& preferredRefreshRate = configId
            ? mRefreshRateConfigs->getRefreshRateFromConfigId(*configId)
            // NOTE: Choose the default config ID, if Scheduler doesn't have one in mind.
            : mRefreshRateConfigs->getRefreshRateFromConfigId(currentPolicy.defaultConfig);
    ALOGV("trying to switch to Scheduler preferred config %d (%s)",
          preferredRefreshRate.getConfigId().value(), preferredRefreshRate.getName().c_str());

    // 判断RefreshRate是否合法
    if (isDisplayConfigAllowed(preferredRefreshRate.getConfigId())) {
        ALOGV("switching to Scheduler preferred config %d",
              preferredRefreshRate.getConfigId().value());
        // 1.4 设置帧率
        setDesiredActiveConfig(
                {preferredRefreshRate.getConfigId(), Scheduler::ConfigEvent::Changed});
    } else {
        LOG_ALWAYS_FATAL("Desired config not allowed: %d",
                         preferredRefreshRate.getConfigId().value());
    }

    return NO_ERROR;
}

1.3.1 RefreshRateConfigs.setDisplayManagerPolicy

status_t RefreshRateConfigs::setDisplayManagerPolicy(const Policy& policy) {
    std::lock_guard lock(mLock);
    if (!isPolicyValid(policy)) {
        return BAD_VALUE;
    }
    // 获取当前策略，如果mOverridePolicy是false，也就是没有覆写
    // 就是用的mDisplayManagerPolicy
    Policy previousPolicy = *getCurrentPolicyLocked();
    mDisplayManagerPolicy = policy;
    if (*getCurrentPolicyLocked() == previousPolicy) {
        return CURRENT_POLICY_UNCHANGED;
    }
    // 1.3.2 根据策略构建最终刷新率
    constructAvailableRefreshRates();
    return NO_ERROR;
}

1.3.2 RefreshRateConfigs.constructAvailableRefreshRates

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);

    // lambuda A
    auto filterRefreshRates = [&](float min, float max, const char* listName,
                                  std::vector<const RefreshRate*>* outRefreshRates) {
        // lambuda B
        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);
}

void RefreshRateConfigs::getSortedRefreshRateList(
        const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
        std::vector<const RefreshRate*>* outRefreshRates) {
    outRefreshRates->clear();
    outRefreshRates->reserve(mRefreshRates.size());
    // 遍历所有可能的RefreshRate
    for (const auto& [type, refreshRate] : mRefreshRates) {
        // 调用上面的lambuda B方法, 其实就是条件判断
        if (shouldAddRefreshRate(*refreshRate)) {
            ALOGV("getSortedRefreshRateList: config %d added to list policy",
                  refreshRate->configId.value());
            outRefreshRates->push_back(refreshRate.get());
        }
    }

    // 按照帧率大小排序，VsyncPeriod越大，Fps越小。
    // 这里就是按照Fps升序排序了
    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();
                  }
              });
}

这里吐槽一下，写的很丑。直接说明，在 mRefreshRates中寻找符合要求的configId(modeId)放入对应的集合中。

这里说的符合要求是指：

  1. 宽高与所设置的Policy中的defaultConfig的宽高一致
  2. 其帧率在所设置的Policy的最小和最大帧率之中

最终将结果保存在变量：mPrimaryRefreshRates以及mAppRequestRefreshRates中。

1.3.3 Scheduler.getPreferredConfigId

std::optional<HwcConfigIndexType> Scheduler::getPreferredConfigId() {
    std::lock_guard<std::mutex> lock(mFeatureStateLock);
    // Make sure that the default config ID is first updated, before returned.
    // mFeatures 是一个结构体
    if (mFeatures.configId.has_value()) {
        // configId是一个 std:optional的变量
        // 计算当前刷新率的configId
        mFeatures.configId = calculateRefreshRateConfigIndexType();
    }
    return mFeatures.configId;
}

这个地方原以为mFeatures.configId一般是存在value的，其实并不是。

1.3.4 Scheduler.calculateRefreshRateConfigIndexType

// consideredSignals 的默认参数是nullptr的
HwcConfigIndexType Scheduler::calculateRefreshRateConfigIndexType(
        scheduler::RefreshRateConfigs::GlobalSignals* consideredSignals) {
    ATRACE_CALL();
    // ......
    const bool touchActive = mTouchTimer && mFeatures.touch == TouchState::Active;
    const bool idle = mIdleTimer && mFeatures.idleTimer == TimerState::Expired;

    // ......
    // 1.3.5 获取最佳ConfigId, 根据framework传来的帧率范围, 以及当下Layer投票产生
    return mRefreshRateConfigs
            .getBestRefreshRate(mFeatures.contentRequirements, {.touch = touchActive, .idle = idle},
                                consideredSignals)
            .getConfigId();
}

1.3.5 RefreshRateConfigs.getBestRefreshRate

const RefreshRate& RefreshRateConfigs::getBestRefreshRate(
        const std::vector<LayerRequirement>& layers, const GlobalSignals& globalSignals,
        GlobalSignals* outSignalsConsidered) const {
    ATRACE_CALL();
    ALOGV("getRefreshRateForContent %zu layers", layers.size());

    // 注意传入的outSignalsConsidered是nullptr的
    if (outSignalsConsidered) *outSignalsConsidered = {};
    const auto setTouchConsidered = [&] {
        if (outSignalsConsidered) {
            outSignalsConsidered->touch = true;
        }
    };

    const auto setIdleConsidered = [&] {
        if (outSignalsConsidered) {
            outSignalsConsidered->idle = true;
        }
    };

    std::lock_guard lock(mLock);
    // 开始投票
    // 首先计算所有不同LayerVoteType的数量
    // 这里的Type稍后介绍
    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;

    // $1. 如果没有显式Layer, 考虑触摸事件, 如果存在触摸事件, 选择最大帧率
    if (globalSignals.touch && !hasExplicitVoteLayers) {
        ALOGV("TouchBoost - choose %s", getMaxRefreshRateByPolicyLocked().getName().c_str());
        setTouchConsidered();
        return getMaxRefreshRateByPolicyLocked();
    }

    // 如果刷新率范围由单个刷新率组成，那么只有当层显式请求不同的刷新率时，才能选择超出范围
    const Policy* policy = getCurrentPolicyLocked();
    const bool primaryRangeIsSingleRate = policy->primaryRange.min == policy->primaryRange.max;

    // $2. 没有touch事件，屏幕处于idle状态, 刷新率存在一定范围或者不存在显示请求刷新率的Layer时
    // 选择最小帧率
    if (!globalSignals.touch && globalSignals.idle &&
        !(primaryRangeIsSingleRate && hasExplicitVoteLayers)) {
        ALOGV("Idle - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
        setIdleConsidered();
        return getMinRefreshRateByPolicyLocked();
    }

    // $3. 没有Layer或者所有Layer都没有投票(NoVote)时, 选择最大帧率？？？
    if (layers.empty() || noVoteLayers == layers.size()) {
        return getMaxRefreshRateByPolicyLocked();
    }

    // $4. 存在Layer且所有Layer要么不投票，要么请求最小帧率时，选择最小帧率
    if (noVoteLayers + minVoteLayers == layers.size()) {
        ALOGV("all layers Min - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());
        return getMinRefreshRateByPolicyLocked();
    }

    // $5. 计算找到最佳刷新率
    std::vector<std::pair<const RefreshRate*, float>> scores;
    scores.reserve(mAppRequestRefreshRates.size());

    for (const auto refreshRate : mAppRequestRefreshRates) {
        scores.emplace_back(refreshRate, 0.0f);
    }

    // 遍历所有Layer
    for (const auto& layer : layers) {
        ALOGV("Calculating score for %s (%s, weight %.2f)", layer.name.c_str(),
              layerVoteTypeString(layer.vote).c_str(), layer.weight);
        // 忽略不投票或者投票选择最小帧率的Layer
        if (layer.vote == LayerVoteType::NoVote || layer.vote == LayerVoteType::Min) {
            continue;
        }

        auto weight = layer.weight;
        // 注意这里还有一层循环，分别计算每个AppRequestRefreshRate的得分
        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 ||
                   layer.vote == LayerVoteType::ExplicitExactOrMultiple))) {
                // $$5.1 只有具有显式帧速率设置的聚焦层才允许对主范围之外的刷新率进行评分
                // 换句话说，只有ExplicitDefault或者ExplicitExactOrMultiple类型的Layer，且该Layer是有焦点的
                // 才允许投票超出刷新率请求范围的帧率
                continue;
            }

            // $$5.2 如果图层想要最大值，给更高的刷新率评分
            if (layer.vote == LayerVoteType::Max) {
                // 用当前layer(app)请求的帧率除以最后一个layer(app)请求的帧率
                // 注意到mAppRequestRefreshRates中fps是按照升序排序的，最后一个是最大的
                // 所以这里就是用 当前请求的帧率除以最大的请求帧率得到一个 (0, 1] 的比值
                const auto ratio = scores[i].first->fps / scores.back().first->fps;
                // 使用比值的平方得到一个较低的分数 ==> 为啥？
                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);
                // 将比值的平方乘上权重系数，作为该layer的分数
                scores[i].second += weight * layerScore;
                continue;
            }

            // 屏幕刷新率
            const auto displayPeriod = scores[i].first->hwcConfig->getVsyncPeriod();
            // Layer所需的刷新率
            const auto layerPeriod = round<nsecs_t>(1e9f / layer.desiredRefreshRate);
            // $$5.3 如果是ExplicitDefault类型的Layer
            if (layer.vote == LayerVoteType::ExplicitDefault) {
                const auto layerScore = [&]() {
                    // 找到Layer将渲染的实际速率，假设layerPeriod是渲染帧的最短时间
                    auto actualLayerPeriod = displayPeriod;
                    int multiplier = 1;
                    // 刷新时长依次翻倍，直到满足该Layer刷新的最低时长，也就是fps大小每次折半
                    // MARGIN_FOR_PERIOD_CALCULATION = 800us
                    while (layerPeriod > actualLayerPeriod + MARGIN_FOR_PERIOD_CALCULATION) {
                        multiplier++;
                        actualLayerPeriod = displayPeriod * multiplier;
                    }
                    // 此时layer分数为 layer所需的时长除以满足刷新要求的最长时长
                    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);
                // layer分数乘上权重作为该layer的最终分数
                scores[i].second += weight * layerScore;
                continue;
            }

            // $$5.4 如果是ExplicitExactOrMultiple或者Heuristic类型的Layer
            if (layer.vote == LayerVoteType::ExplicitExactOrMultiple ||
                layer.vote == LayerVoteType::Heuristic) {
                const auto layerScore = [&] {
                    // 计算我们需要多少个显示vSync来显示这个层的一个帧
                    // 其实就是计算 layerPeriod/displayPeriod 得到商和余数
                    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) {
                        // 整除的时候，直接返回1?
                        // 说明layer请求的fps是比display的fps小，得分直接拉满
                        return 1.0f;
                    }

                    if (displayFramesQuot == 0) {
                        // 当layer请求的fps比display中的fps要大的时候
                        // 返回layer period除以display period的商的十一分之一
                        // 比如 layer = 120Hz， display = 90Hz
                        //                    8.33333         1.0
                        //  return =  -----------  *   ----
                        //                     11.1111         11
                        // 为啥怎么算呢，这里分数的极限值也就是1/11，最大限度排除这个layer请求的帧率？
                        return (static_cast<float>(layerPeriod) /
                                static_cast<float>(displayPeriod)) *
                                (1.0f / (MAX_FRAMES_TO_FIT + 1));
                    }

                    // layer所需的刷新率低于的显示刷新率，但又不是整数倍关系，检查它是否符合节奏
                    // 计算差值: 用 Pl 表述 layer period，Pd表示display period
                    // diff = | (Pl mod Pd) * 2 - Pd |
                    // 这里的意思是在计算多少帧内，display 刷新可以匹配 layer请求的刷新
                    auto diff = std::abs(displayFramesRem - (displayPeriod - displayFramesRem));
                    int iter = 2;
                    while (diff > MARGIN_FOR_PERIOD_CALCULATION && iter < MAX_FRAMES_TO_FIT) {
                        // 循环计算，总结公式：
                        // 1. diff0 = 2 * (Pl mod Pd) - Pd, Pl > Pd 且 K ∈ {1,2,3,...,9}
                        // 2. 当diff0 > 0 时, diff = (Pl mod Pd) * 2^k - Pd * (2^k-1)
                        // 3. 当diff0 < 0 时, diff = Pd - 2^k * (Pl mode Pd)
                        diff = diff - (displayPeriod - diff);
                        iter++;
                    }

                    // 得分取值范围是[0.1, 0.5]
                    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;
            }
        }
    }

    // $6 如果存在请求最大帧率的layer就反向遍历
    // 找到得分最大的帧率
    const RefreshRate* bestRefreshRate = maxVoteLayers > 0
            ? getBestRefreshRate(scores.rbegin(), scores.rend())
            : getBestRefreshRate(scores.begin(), scores.end());

    // 显示主刷新率没有范围，只有定值时
    if (primaryRangeIsSingleRate) {
        // 如果没有layer参与评分，从显示主刷新范围选取最大值
        // 否则返回计算得出的最佳刷新率
        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;
        }
    }

    // 如果没有explicitDefaultLayers，请考虑touch事件。
    // ExplicitDefault主要是交互式的（与ExplicitExactOrMultiple相反），因此如果那些Layer发布了一个显式投票，
    // 那么存在touch事件，就不应该更改它。只有在触摸增强会增加刷新率超过正常选择时才应用。
    const RefreshRate& touchRefreshRate = getMaxRefreshRateByPolicyLocked();

    // 存在touch事件，不存在ExplicitDefault的Layer且显示主范围刷新率最大值大于计算的刷新率时
    // 采用最大刷新率
    if (globalSignals.touch && explicitDefaultVoteLayers == 0 &&
        bestRefreshRate->fps < touchRefreshRate.fps) {
        setTouchConsidered();
        ALOGV("TouchBoost - choose %s", touchRefreshRate.getName().c_str());
        return touchRefreshRate;
    }

    return *bestRefreshRate;
}

Emmmm… 这一言难尽的代码。

总结一下，在上层计算传入两个刷新率范围后，这里主要是根据Layer投票以及一系列判断得到最终所需的刷新率。

说明一下几个概念：

  1. 显示主范围刷新率: DisplayModeDirector中投票算出的包含所有请求帧率的最小范围
  2. layerPeriod: 根据当前layer.desiredRefreshRate计算出一帧的时长
  3. displayPeriod: 当前AppReqeustRefereshRate中HwcConfig计算的一帧时长

整个投票过程简述:

  1. 首先计算所有不同LayerVoteType的数量
  2. 如果没有显式Layer,即ExplicitDefault和ExplicitExactOrMultiple类型,且存在触摸事件, 直接选择主范围刷新率最大帧率
  3. 没有touch事件且屏幕处于idle状态, 刷新率存在一定范围或者不存在显示请求刷新率的Layer时, 选择主范围刷新率最小帧率
  4. 没有Layer或者所有Layer都没有投票(NoVote)时, 选择最大帧率
  5. 存在Layer且所有Layer要么不投票，要么请求最小帧率时，选择最小帧率
  6. 当上述条件都不满足时，遍历所有Layer计算每个AppRequestRefreshRate的得分，找到最佳刷新率, 注意遍历时, 忽略不投票或者投票选择最小帧率的Layer
    1. 遍历所有AppRequestRefreshRate
      1. 只有ExplicitDefault或者ExplicitExactOrMultiple类型的Layer，且该Layer是有焦点的才允许投票超出刷新率请求范围的帧率，否则忽略该Layer
      2. 如果Layer是Max类型
        1. 用当前layer(app)请求的帧率除以最后一个layer(app)请求的帧率,得到的比值的平方乘以权重，计入当前AppRequestRefreshRate的分数
      3. 如果是ExplicitDefault类型的Layer
        1. 找到Layer将渲染的实际速率，首先假设layer.desiredRefreshRate计算的Period是渲染帧的最短时间
        2. 将该AppReqeustRefereshRate中的Display Period刷新时长依次翻倍，直到满足该Layer刷新的最低时长，也就是fps大小每次折半
        3. 此时layer分数为 layer所需的时长除以满足刷新要求的最长时长在乘以权重计入当前AppRequestRefreshRate的分数
      4. 如果是ExplicitExactOrMultiple或者Heuristic类型的Layer
        1. 首先计算需要多少个显示vSync来显示这个层的一个帧，即计算 layerPeriod/displayPeriod 得到商 quot 和余数 rem
        2. 如果是整数倍关系，当前AppRequestRefreshRate的分数直接加上该Layer的权重
        3. 当layer请求的fps比AppReqeustRefereshRate中的实际display的fps要大的时候，得分是layer period除以display period的商的十一分之一乘以layer的权重
        4. layer所需的刷新率低于的显示刷新率，但又不是整数倍关系时，用 Pl 表述 layer period，Pd表示display period
          1. diff0 = 2 * (Pl mod Pd) - Pd, Pl > Pd 且 K ∈ {1,2,3,…,9}
          2. 当diff0 > 0 时, diff = (Pl mod Pd) * 2^k - Pd * (2^k-1)
          3. 当diff0 < 0 时, diff = Pd - 2^k * (Pl mode Pd)
          4. 当diff小于800时(差值小于800us), 或者k>9结束, 得分是当前Layer的权重乘以1/(2K),也就是说帧率差别越大的layer权重越小，对该帧率的倾向程度越低
  7. 如果存在请求最大帧率的layer就反向遍历,找到得分最大的帧率 bestRefreshRate
  8. 如果显示主刷新率没有范围，比如最小值和最大值都是120Hz时
    1. 如果没有layer参与评分，从显示主刷新范围选取最大值
    2. 否则返回计算得出的最佳刷新率
  9. 如果存在touch事件, 不存在ExplicitDefault的Layer且显示主范围刷新率最大值大于计算的刷新率时, 采用最大刷新率
  10. 以上条件均不满足时，返回计算的bestRefreshRate

好了，本次分析到此为止，接下来就是继续看SurfaceFlinger如何通知HWC硬件切换帧率了。

SwallowJoe
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
android virtualdisplay_控制VirtualDisplay的帧速率
weixin_28755331的博客
01-17 1129
I'm writing an Android application, and in it, I have a VirtualDisplay to mirror what is on the screen and I then send the frames from the screen to an instance of a MediaCodec. It works, but, I want ...
Android--开发--Adroid UI 界面绘制原理分析.rar
04-10
3. **布局管理器(Layout Manager)**：虽然布局管理器并不直接属于Android UI的绘制原理，但它们是实现复杂布局的关键。布局管理器负责决定视图如何在视图组内排列。例如，LinearLayout按照垂直或水平方向排列子视图...
Android帧率修改
qq_41740004的博客
11-10 769
【代码】Android帧率修改。
Android中可变帧率VRR
april_12345的博客
06-27 4237
Android 从Q开始实现对可变帧率（VRR：Variable Refresh Rate）的支持。本文以android Q 为基础介绍android VRR的实现， 与android S有部分差别，但大体流程相同。
Android13 DisplayManagerService启动流程分析
最新发布
liuning1985622的博客
05-05 934
DisplayManagerService的onStart方法主要加载持久化数据（主要是显示设备的宽高等），发送 MSG_REGISTER_DEFAULT_DISPLAY_ADAPTERS消息，对外公布Binder、Local Service等。1、调用DisplayManagerService的getBrightnessConfigForDisplayWithPdsFallbackLocked方法，获取亮度相关配置。
Android SurfaceView 绘图及帧频处理方法修正
weixin_33724046的博客
11-08 217
此文是针对上一篇《Android SurfaceView 绘图覆盖刷新及脏矩形刷新方法》的修正。   帧频处理 今天我在审视上篇示例代码时猛然发现我犯了个低级错误，致使帧频达不到预期，这个错误在这里： 这里设置每次绘制之后固定休眠33毫秒，以此来限制每秒帧频在30帧。 但实际上这里忽视了绘图及其他运算所消耗的时间，也就是说除非其他所有操作的总耗时都不足1/3毫秒，否则我们就根本无法达到每秒30帧...
Android 11系统升级踩坑
虚无世界的专栏
03-15 370
有用户反馈，某个售后页面信息看不完整（页面是H5页面），但是几个月前的版本是显示正常 Android 10 webview加载html片段，内容显示不完整？ 首先去查看了，Android10的更新信息，并没有提示web有什么配置，直接查看加载Api，发现Android 10以后，对于**#** 特殊字符，都需要Base64编码处理，否则会默认截断#后面的文字内容 ...
Android UI架构(十三)--App请求切换帧率(4)之SurfaceFlinger切换帧率.md
SwallowJoe的博客
10-09 4483
文章目录参考资料简述一. SurfaceFlinger接受帧率变化1.1 SurfaceFlinger.setDesiredActiveConfig1.2 SurfaceFlinger.repaintEverythingForHWC1.3 Scheduler.resyncToHardwareVsync1.3.1 Scheduler.setVsyncPeriod1.3.2 VSyncReactor.setPeriod1.3.3 VSyncReactor.startPeriodTransition1.4 VSy
Android 图像冰冻特效源码-IT计算机-毕业设计.zip
04-05
1. **Android图形系统**: Android的图形系统基于SurfaceFlinger服务，它负责合成窗口、动画和特效。了解OpenGL ES、Canvas、Bitmap和Drawable等基本组件是实现图像特效的基础。 2. **OpenGL ES**: OpenGL ES ...
【计算机专业-Andorid项目源码100套之】Adroid UI界面绘制原理分析
04-10
Android UI界面绘制原理是Android应用开发中的核心概念，它涉及到屏幕显示、布局管理、图形绘制等多个方面。在Android系统中，UI界面的构建基于View和ViewGroup两类组件，它们共同构成了用户界面的基础框架。 首先...
Android应用程序UI架构 高清PTT
10-23
Android系统采用一种称为Surface的UI架构为应用程序提供用户界面。在Android应用程序中，每一个Activity组件都关联有一个或者若干个窗口，每一个窗口都对应有一个Surface。有了这个Surface之后，应用程序就可以在...
vsync 生产、vsync-app 和 vsync-sf 请求、响应
05-06
本篇文章将深入探讨`vsync`的生产、`vsync-app`和`vsync-sf`请求与响应机制，以及它们在软件开发中的应用。 首先，`vsync`是一种确保显示器和GPU之间同步的技术，防止图像撕裂现象。当GPU渲染的帧率与显示器刷新率...
Android13实时刷新频率的实现代码
u010345983的博客
05-17 960
RefreshRateOverlay实际Layer显示刷新频率。初始化RefreshRateOverlay。设置->开发者选项->显示刷新频率。
Android获取当前应用FPS（帧数）
小傲傲的博客
10-12 3229
Android获取本软件（Application）的帧率
Android 10 (Android Q)中的屏幕刷新率(display refresh rate)切换方法和策略
qianxuedegushi的博客
04-14 6296
转自：Android 10 (Android Q)中的屏幕刷新率(display refresh rate)切换方法和策略_whoatenereyhow的博客-CSDN博客_android 刷新率 1. 屏幕刷新率和应用的显示帧率 首先请区分好屏幕刷新率(Panel Refresh Rate)和应用的帧率(APP Frame Rate)两个概念。 屏幕刷新率是显示器（LCD/OLED等）的硬件性能参数，即它每秒钟能刷新几幅画面，一般用物理单位Hz来表示。我们知道显示器的面板始...
AndroidFrameWork切换帧率
u010029439的博客
02-17 1165
注意到在步骤#1.2中也就是repaintEverythingForHWC会请求下一帧的Vsync，很自然的想法就是实际帧率切换应该是在下一帧到来的时候才开始的。上面的流程跑完后，实际上硬件帧率在哪儿切换还是没有看到，包括mPeriodTransitioningTo是怎么更新到实际软件Vsync中的呢？比如硬件Vsync是怎么影响到VsyncRecator产生软件Vsync的，或者软件Vsync和硬件Vsync是怎么校准的。// 这里根据帧率大小，分两种情况获取偏移量，具体就不看了，和参数配置相关。
SurfaceFlinger详解
xxdw1992的博客
02-13 2034
SurfaceFlinger的定义那么 Systrace 中，我们关注的重点就是上面这幅图对应的部分这四部分，在 Systrace 中都有可以对应的地方，以时间发生的顺序排序就是 1、2、3、4，下面我们从 Systrace 的这四部分来看整个渲染的流程。负责图像合成的核心模块是 负责图像合成的节奏和合成策略的分配。
【安卓源码】SurfaceFlinger 启动及其与应用通信
mike_jun的博客
03-19 1242
surfaceflinger 的makefile 文件init进程就可以解析 "surfaceflinger.rc" ，启动 SurfaceFlinger 服务进程，执行 main 方法，启动surfaceflinger 进程：基本操作如下：调用的是 SurfaceFlingerFactory 头文件创建了消息队列 mFactory.createMessageQueueDefaultFactory 头文件创建独占智能指针 MessageQueue代码路径为如下：方法解析。
dumpsys SurfaceFlinger --latency-clear中的latency-clear是什么意思
06-01
在dumpsys SurfaceFlinger命令中，latency-clear表示清除之前的帧延迟数据。具体来说，SurfaceFlinger是Android系统中的一个服务，负责将各个应用程序的窗口进行组合并渲染到屏幕上。在进行渲染时，SurfaceFlinger会记录每个帧的渲染时间，并计算出帧延迟（即从应用程序提交渲染请求到渲染完成的时间间隔）。 通过执行dumpsys SurfaceFlinger --latency-clear命令，可以清除之前记录的帧延迟数据，并重新开始记录。这个命令通常用于测试应用程序的渲染性能，以便更好地优化应用程序的帧率和响应速度。 另外，需要注意的是，执行这个命令需要在root权限下进行。如果没有root权限，可以通过adb调试工具来执行这个命令，例如使用“adb shell dumpsys SurfaceFlinger --latency-clear”命令来清除之前的帧延迟数据。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值