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

Commit ee5e78a1 authored by Ady Abraham's avatar Ady Abraham Committed by Android (Google) Code Review
Browse files

Merge changes from topic "sf_render_frame_rate"

* changes:
  SF: Generalize frame rate override to any frame rate
  SF: store the render frame rate in RefreshRateConfigs::Policy
parents 240da1a8 8ca643a3
Loading
Loading
Loading
Loading
+7 −27
Original line number Diff line number Diff line
@@ -2375,42 +2375,22 @@ status_t SurfaceComposerClient::getActiveDisplayMode(const sp<IBinder>& display,
    return NAME_NOT_FOUND;
}

status_t SurfaceComposerClient::setDesiredDisplayModeSpecs(
        const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode, bool allowGroupSwitching,
        float primaryRefreshRateMin, float primaryRefreshRateMax, float appRequestRefreshRateMin,
        float appRequestRefreshRateMax) {
status_t SurfaceComposerClient::setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
                                                           const gui::DisplayModeSpecs& specs) {
    binder::Status status =
            ComposerServiceAIDL::getComposerService()
                    ->setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,
                                                 primaryRefreshRateMin, primaryRefreshRateMax,
                                                 appRequestRefreshRateMin,
                                                 appRequestRefreshRateMax);
            ComposerServiceAIDL::getComposerService()->setDesiredDisplayModeSpecs(displayToken,
                                                                                  specs);
    return statusTFromBinderStatus(status);
}

status_t SurfaceComposerClient::getDesiredDisplayModeSpecs(const sp<IBinder>& displayToken,
                                                           ui::DisplayModeId* outDefaultMode,
                                                           bool* outAllowGroupSwitching,
                                                           float* outPrimaryRefreshRateMin,
                                                           float* outPrimaryRefreshRateMax,
                                                           float* outAppRequestRefreshRateMin,
                                                           float* outAppRequestRefreshRateMax) {
    if (!outDefaultMode || !outAllowGroupSwitching || !outPrimaryRefreshRateMin ||
        !outPrimaryRefreshRateMax || !outAppRequestRefreshRateMin || !outAppRequestRefreshRateMax) {
                                                           gui::DisplayModeSpecs* outSpecs) {
    if (!outSpecs) {
        return BAD_VALUE;
    }
    gui::DisplayModeSpecs specs;
    binder::Status status =
            ComposerServiceAIDL::getComposerService()->getDesiredDisplayModeSpecs(displayToken,
                                                                                  &specs);
    if (status.isOk()) {
        *outDefaultMode = specs.defaultMode;
        *outAllowGroupSwitching = specs.allowGroupSwitching;
        *outPrimaryRefreshRateMin = specs.primaryRefreshRateMin;
        *outPrimaryRefreshRateMax = specs.primaryRefreshRateMax;
        *outAppRequestRefreshRateMin = specs.appRequestRefreshRateMin;
        *outAppRequestRefreshRateMax = specs.appRequestRefreshRateMax;
    }
                                                                                  outSpecs);
    return statusTFromBinderStatus(status);
}

+52 −4
Original line number Diff line number Diff line
@@ -18,10 +18,58 @@ package android.gui;

/** @hide */
parcelable DisplayModeSpecs {
    /**
     * Defines the refresh rates ranges that should be used by SF.
     */
    parcelable RefreshRateRanges {
        /**
         * Defines a range of refresh rates.
         */
        parcelable RefreshRateRange {
            float min;
            float max;
        }

        /**
         *  The range of refresh rates that the display should run at.
         */
        RefreshRateRange physical;

        /**
         *  The range of refresh rates that apps should render at.
         */
        RefreshRateRange render;
    }

    /**
     * Base mode ID. This is what system defaults to for all other settings, or
     * if the refresh rate range is not available.
     */
    int defaultMode;

    /**
     * If true this will allow switching between modes in different display configuration
     * groups. This way the user may see visual interruptions when the display mode changes.
     */

    boolean allowGroupSwitching;
    float primaryRefreshRateMin;
    float primaryRefreshRateMax;
    float appRequestRefreshRateMin;
    float appRequestRefreshRateMax;

    /**
     * The primary physical and render refresh rate ranges represent DisplayManager's general
     * guidance on the display modes SurfaceFlinger will consider when switching refresh
     * rates and scheduling the frame rate. Unless SurfaceFlinger has a specific reason to do
     * otherwise, it will stay within this range.
     */
    RefreshRateRanges primaryRanges;

    /**
     * The app request physical and render refresh rate ranges allow SurfaceFlinger to consider
     * more display modes when switching refresh rates. Although SurfaceFlinger will
     * generally stay within the primary range, specific considerations, such as layer frame
     * rate settings specified via the setFrameRate() API, may cause SurfaceFlinger to go
     * outside the primary range. SurfaceFlinger never goes outside the app request range.
     * The app request range will be greater than or equal to the primary refresh rate range,
     * never smaller.
     */
    RefreshRateRanges appRequestRanges;
}
+3 −19
Original line number Diff line number Diff line
@@ -327,25 +327,9 @@ interface ISurfaceComposer {
    /**
     * Sets the refresh rate boundaries for the display.
     *
     * The primary refresh rate range represents display manager's general guidance on the display
     * modes we'll consider when switching refresh rates. Unless we get an explicit signal from an
     * app, we should stay within this range.
     *
     * The app request refresh rate range allows us to consider more display modes when switching
     * refresh rates. Although we should generally stay within the primary range, specific
     * considerations, such as layer frame rate settings specified via the setFrameRate() api, may
     * cause us to go outside the primary range. We never go outside the app request range. The app
     * request range will be greater than or equal to the primary refresh rate range, never smaller.
     *
     * defaultMode is used to narrow the list of display modes SurfaceFlinger will consider
     * switching between. Only modes with a mode group and resolution matching defaultMode
     * will be considered for switching. The defaultMode corresponds to an ID of mode in the list
     * of supported modes returned from getDynamicDisplayInfo().
     */
    void setDesiredDisplayModeSpecs(
            IBinder displayToken, int defaultMode,
            boolean allowGroupSwitching, float primaryRefreshRateMin, float primaryRefreshRateMax,
            float appRequestRefreshRateMin, float appRequestRefreshRateMax);
     * @see DisplayModeSpecs.aidl for details.
     */
    void setDesiredDisplayModeSpecs(IBinder displayToken, in DisplayModeSpecs specs);

    DisplayModeSpecs getDesiredDisplayModeSpecs(IBinder displayToken);

+1 −3
Original line number Diff line number Diff line
@@ -127,9 +127,7 @@ public:
    MOCK_METHOD(binder::Status, removeTunnelModeEnabledListener,
                (const sp<gui::ITunnelModeEnabledListener>&), (override));
    MOCK_METHOD(binder::Status, setDesiredDisplayModeSpecs,
                (const sp<IBinder>&, int32_t, bool, float, float, float,
                 float appRequestRefreshRateMax),
                (override));
                (const sp<IBinder>&, const gui::DisplayModeSpecs&), (override));
    MOCK_METHOD(binder::Status, getDesiredDisplayModeSpecs,
                (const sp<IBinder>&, gui::DisplayModeSpecs*), (override));
    MOCK_METHOD(binder::Status, getDisplayBrightnessSupport, (const sp<IBinder>&, bool*),
+28 −6
Original line number Diff line number Diff line
@@ -123,10 +123,37 @@ private:
    sp<SurfaceControl> makeSurfaceControl();
    BlurRegion getBlurRegion();
    void fuzzOnPullAtom();
    gui::DisplayModeSpecs getDisplayModeSpecs();

    FuzzedDataProvider mFdp;
};

gui::DisplayModeSpecs SurfaceComposerClientFuzzer::getDisplayModeSpecs() {
    const auto getRefreshRateRange = [&] {
        gui::DisplayModeSpecs::RefreshRateRanges::RefreshRateRange range;
        range.min = mFdp.ConsumeFloatingPoint<float>();
        range.max = mFdp.ConsumeFloatingPoint<float>();
        return range;
    };

    const auto getRefreshRateRanges = [&] {
        gui::DisplayModeSpecs::RefreshRateRanges ranges;
        ranges.physical = getRefreshRateRange();
        ranges.render = getRefreshRateRange();
        return ranges;
    };

    String8 displayName((mFdp.ConsumeRandomLengthString(kRandomStringMaxBytes)).c_str());
    sp<IBinder> displayToken =
            SurfaceComposerClient::createDisplay(displayName, mFdp.ConsumeBool() /*secure*/);
    gui::DisplayModeSpecs specs;
    specs.defaultMode = mFdp.ConsumeIntegral<int32_t>();
    specs.allowGroupSwitching = mFdp.ConsumeBool();
    specs.primaryRanges = getRefreshRateRanges();
    specs.appRequestRanges = getRefreshRateRanges();
    return specs;
}

BlurRegion SurfaceComposerClientFuzzer::getBlurRegion() {
    int32_t left = mFdp.ConsumeIntegral<int32_t>();
    int32_t right = mFdp.ConsumeIntegral<int32_t>();
@@ -247,12 +274,7 @@ void SurfaceComposerClientFuzzer::invokeSurfaceComposerClient() {
    String8 displayName((mFdp.ConsumeRandomLengthString(kRandomStringMaxBytes)).c_str());
    sp<IBinder> displayToken =
            SurfaceComposerClient::createDisplay(displayName, mFdp.ConsumeBool() /*secure*/);
    SurfaceComposerClient::setDesiredDisplayModeSpecs(displayToken, mFdp.ConsumeIntegral<int32_t>(),
                                                      mFdp.ConsumeBool() /*allowGroupSwitching*/,
                                                      mFdp.ConsumeFloatingPoint<float>(),
                                                      mFdp.ConsumeFloatingPoint<float>(),
                                                      mFdp.ConsumeFloatingPoint<float>(),
                                                      mFdp.ConsumeFloatingPoint<float>());
    SurfaceComposerClient::setDesiredDisplayModeSpecs(displayToken, getDisplayModeSpecs());

    ui::ColorMode colorMode = mFdp.PickValueInArray(kColormodes);
    SurfaceComposerClient::setActiveColorMode(displayToken, colorMode);
Loading