Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9a6cfce7 authored by ramindani's avatar ramindani Committed by Ram Indani
Browse files

[SF] Change FrameRateCategory Max range to 120 

When we cap the refresh rate we don't select the
higher refresh rate for the cases when multiple
layers vote for the lower rate.
This affects the frames which request the higher
rate along side the frames that vote for
lower rate.
This change will give the higher refresh
rate an equal amount of weight in this case.

Test: atest RefreshRateSelectorTest
Bug: 328084623
Change-Id: I8a48e2b066e8908ff8f7579615260d8c74a79bff
parent 4b884cf1

services/surfaceflinger/Scheduler/RefreshRateSelector.cpp

+2 −4
Original line number Diff line number Diff line
@@ -1554,19 +1554,17 @@ FpsRange RefreshRateSelector::getFrameRateCategoryRange(FrameRateCategory catego 
        case FrameRateCategory::High:

            return FpsRange{90_Hz, 120_Hz};

        case FrameRateCategory::Normal:

            return FpsRange{60_Hz, 90_Hz};

            return FpsRange{60_Hz, 120_Hz};

        case FrameRateCategory::Low:

            return FpsRange{30_Hz, 30_Hz};

            return FpsRange{30_Hz, 120_Hz};

        case FrameRateCategory::HighHint:

        case FrameRateCategory::NoPreference:

        case FrameRateCategory::Default:

            LOG_ALWAYS_FATAL("Should not get fps range for frame rate category: %s",

                             ftl::enum_string(category).c_str());

            return FpsRange{0_Hz, 0_Hz};

        default:

            LOG_ALWAYS_FATAL("Invalid frame rate category for range: %s",

                             ftl::enum_string(category).c_str());

            return FpsRange{0_Hz, 0_Hz};

    }

}

services/surfaceflinger/tests/unittests/RefreshRateSelectorTest.cpp

+130 −2
Original line number Diff line number Diff line
@@ -259,6 +259,44 @@ protected: 
        config.enableFrameRateOverride = GetParam();

        return TestableRefreshRateSelector(modes, activeModeId, config);

    }



    template <class T>

    void testFrameRateCategoryWithMultipleLayers(const std::initializer_list<T>& testCases,

                                                 const TestableRefreshRateSelector& selector) {

        std::vector<LayerRequirement> layers;

        for (auto testCase : testCases) {

            ALOGI("**** %s: Testing desiredFrameRate=%s, frameRateCategory=%s", __func__,

                  to_string(testCase.desiredFrameRate).c_str(),

                  ftl::enum_string(testCase.frameRateCategory).c_str());



            if (testCase.desiredFrameRate.isValid()) {

                std::stringstream ss;

                ss << to_string(testCase.desiredFrameRate)

                   << ftl::enum_string(testCase.frameRateCategory) << "ExplicitDefault";

                LayerRequirement layer = {.name = ss.str(),

                                          .vote = LayerVoteType::ExplicitDefault,

                                          .desiredRefreshRate = testCase.desiredFrameRate,

                                          .weight = 1.f};

                layers.push_back(layer);

            }



            if (testCase.frameRateCategory != FrameRateCategory::Default) {

                std::stringstream ss;

                ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";

                LayerRequirement layer = {.name = ss.str(),

                                          .vote = LayerVoteType::ExplicitCategory,

                                          .frameRateCategory = testCase.frameRateCategory,

                                          .weight = 1.f};

                layers.push_back(layer);

            }



            EXPECT_EQ(testCase.expectedFrameRate,

                      selector.getBestFrameRateMode(layers).modePtr->getPeakFps())

                    << "Did not get expected frame rate for frameRate="

                    << to_string(testCase.desiredFrameRate)

                    << " category=" << ftl::enum_string(testCase.frameRateCategory);

        }

    }

};



RefreshRateSelectorTest::RefreshRateSelectorTest() {
@@ -1542,6 +1580,96 @@ TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_30_60 
    }

}



TEST_P(RefreshRateSelectorTest,

       getBestFrameRateMode_withFrameRateCategoryMultiLayers_30_60_90_120) {

    auto selector = createSelector(makeModes(kMode30, kMode60, kMode90, kMode120), kModeId60);



    struct Case {

        // Params

        Fps desiredFrameRate = 0_Hz;

        FrameRateCategory frameRateCategory = FrameRateCategory::Default;



        // Expected result

        Fps expectedFrameRate = 0_Hz;

    };



    testFrameRateCategoryWithMultipleLayers(

            std::initializer_list<Case>{

                    {0_Hz, FrameRateCategory::High, 90_Hz},

                    {0_Hz, FrameRateCategory::NoPreference, 90_Hz},

                    {0_Hz, FrameRateCategory::Normal, 90_Hz},

                    {0_Hz, FrameRateCategory::Normal, 90_Hz},

                    {0_Hz, FrameRateCategory::NoPreference, 90_Hz},

            },

            selector);



    testFrameRateCategoryWithMultipleLayers(

            std::initializer_list<Case>{

                    {0_Hz, FrameRateCategory::Normal, 60_Hz},

                    {0_Hz, FrameRateCategory::High, 90_Hz},

                    {0_Hz, FrameRateCategory::NoPreference, 90_Hz},

            },

            selector);



    testFrameRateCategoryWithMultipleLayers(

            std::initializer_list<Case>{

                    {30_Hz, FrameRateCategory::High, 90_Hz},

                    {24_Hz, FrameRateCategory::High, 120_Hz},

                    {12_Hz, FrameRateCategory::Normal, 120_Hz},

                    {30_Hz, FrameRateCategory::NoPreference, 120_Hz},



            },

            selector);



    testFrameRateCategoryWithMultipleLayers(

            std::initializer_list<Case>{

                    {24_Hz, FrameRateCategory::Default, 120_Hz},

                    {30_Hz, FrameRateCategory::Default, 120_Hz},

                    {120_Hz, FrameRateCategory::Default, 120_Hz},

            },

            selector);

}



TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategoryMultiLayers_60_120) {

    auto selector = createSelector(makeModes(kMode60, kMode120), kModeId60);



    struct Case {

        // Params

        Fps desiredFrameRate = 0_Hz;

        FrameRateCategory frameRateCategory = FrameRateCategory::Default;



        // Expected result

        Fps expectedFrameRate = 0_Hz;

    };



    testFrameRateCategoryWithMultipleLayers(std::initializer_list<

                                                    Case>{{0_Hz, FrameRateCategory::High, 120_Hz},

                                                          {0_Hz, FrameRateCategory::NoPreference,

                                                           120_Hz},

                                                          {0_Hz, FrameRateCategory::Normal, 120_Hz},

                                                          {0_Hz, FrameRateCategory::Normal, 120_Hz},

                                                          {0_Hz, FrameRateCategory::NoPreference,

                                                           120_Hz}},

                                            selector);



    testFrameRateCategoryWithMultipleLayers(std::initializer_list<

                                                    Case>{{24_Hz, FrameRateCategory::High, 120_Hz},

                                                          {30_Hz, FrameRateCategory::High, 120_Hz},

                                                          {12_Hz, FrameRateCategory::Normal,

                                                           120_Hz},

                                                          {30_Hz, FrameRateCategory::NoPreference,

                                                           120_Hz}},

                                            selector);



    testFrameRateCategoryWithMultipleLayers(

            std::initializer_list<Case>{

                    {24_Hz, FrameRateCategory::Default, 120_Hz},

                    {30_Hz, FrameRateCategory::Default, 120_Hz},

                    {120_Hz, FrameRateCategory::Default, 120_Hz},

            },

            selector);

}



TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_60_120) {

    auto selector = createSelector(makeModes(kMode60, kMode120), kModeId60);
@@ -1725,8 +1853,8 @@ TEST_P(RefreshRateSelectorTest, 
            // These layers cannot change mode due to smoothSwitchOnly, and will definitely use

            // active mode (120Hz).

            {FrameRateCategory::NoPreference, true, 120_Hz, kModeId120},

            {FrameRateCategory::Low, true, 120_Hz, kModeId120},

            {FrameRateCategory::Normal, true, 40_Hz, kModeId120},

            {FrameRateCategory::Low, true, 40_Hz, kModeId120},

            {FrameRateCategory::Normal, true, 120_Hz, kModeId120},

            {FrameRateCategory::High, true, 120_Hz, kModeId120},

    };