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

Commit d7466cd8 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 11881322 from 67ea1030 to 24Q3-release 

Change-Id: I80455e0a5bf20f06c5c7f1d91600d746b88f6bc8
parents 5f7fe0f5 67ea1030

services/inputflinger/reader/mapper/MultiTouchInputMapper.cpp

+2 −1
Original line number Diff line number Diff line
@@ -138,13 +138,14 @@ void MultiTouchInputMapper::syncTouch(nsecs_t when, RawState* outState) { 


        // Assign pointer id using tracking id if available.

        if (mHavePointerIds) {

            int32_t trackingId = inSlot.getTrackingId();

            const int32_t trackingId = inSlot.getTrackingId();

            int32_t id = -1;

            if (trackingId >= 0) {

                for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty();) {

                    uint32_t n = idBits.clearFirstMarkedBit();

                    if (mPointerTrackingIdMap[n] == trackingId) {

                        id = n;

                        break;

                    }

                }

services/surfaceflinger/DisplayDevice.cpp

+2 −2
Original line number Diff line number Diff line
@@ -485,11 +485,11 @@ void DisplayDevice::enableRefreshRateOverlay(bool enable, bool setByHwc, bool sh 
    }

}



void DisplayDevice::updateRefreshRateOverlayRate(Fps vsyncRate, Fps renderFps, bool setByHwc) {

void DisplayDevice::updateRefreshRateOverlayRate(Fps refreshRate, Fps renderFps, bool setByHwc) {

    ATRACE_CALL();

    if (mRefreshRateOverlay) {

        if (!mRefreshRateOverlay->isSetByHwc() || setByHwc) {

            mRefreshRateOverlay->changeRefreshRate(vsyncRate, renderFps);

            mRefreshRateOverlay->changeRefreshRate(refreshRate, renderFps);

        } else {

            mRefreshRateOverlay->changeRenderRate(renderFps);

        }

services/surfaceflinger/DisplayDevice.h

+1 −1
Original line number Diff line number Diff line
@@ -226,7 +226,7 @@ public: 
    // Enables an overlay to be displayed with the current refresh rate

    void enableRefreshRateOverlay(bool enable, bool setByHwc, bool showSpinner, bool showRenderRate,

                                  bool showInMiddle) REQUIRES(kMainThreadContext);

    void updateRefreshRateOverlayRate(Fps vsyncRate, Fps renderFps, bool setByHwc = false);

    void updateRefreshRateOverlayRate(Fps refreshRate, Fps renderFps, bool setByHwc = false);

    bool isRefreshRateOverlayEnabled() const { return mRefreshRateOverlay != nullptr; }

    bool onKernelTimerChanged(std::optional<DisplayModeId>, bool timerExpired);

services/surfaceflinger/RefreshRateOverlay.cpp

+14 −13
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ 


namespace android {



auto RefreshRateOverlay::draw(int vsyncRate, int renderFps, SkColor color,

auto RefreshRateOverlay::draw(int refreshRate, int renderFps, SkColor color,

                              ui::Transform::RotationFlags rotation, ftl::Flags<Features> features)

        -> Buffers {

    const size_t loopCount = features.test(Features::Spinner) ? 6 : 1;
@@ -71,7 +71,7 @@ auto RefreshRateOverlay::draw(int vsyncRate, int renderFps, SkColor color, 
        canvas->setMatrix(canvasTransform);



        int left = 0;

        drawNumber(vsyncRate, left, color, *canvas);

        drawNumber(refreshRate, left, color, *canvas);

        left += 3 * (kDigitWidth + kDigitSpace);

        if (features.test(Features::Spinner)) {

            switch (i) {
@@ -171,7 +171,7 @@ bool RefreshRateOverlay::initCheck() const { 
    return mSurfaceControl != nullptr;

}



auto RefreshRateOverlay::getOrCreateBuffers(Fps vsyncRate, Fps renderFps) -> const Buffers& {

auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps) -> const Buffers& {

    static const Buffers kNoBuffers;

    if (!mSurfaceControl) return kNoBuffers;
@@ -198,16 +198,16 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps vsyncRate, Fps renderFps) -> con 
    createTransaction().setTransform(mSurfaceControl->get(), transform).apply();



    BufferCache::const_iterator it =

            mBufferCache.find({vsyncRate.getIntValue(), renderFps.getIntValue(), transformHint});

            mBufferCache.find({refreshRate.getIntValue(), renderFps.getIntValue(), transformHint});

    if (it == mBufferCache.end()) {

        // HWC minFps is not known by the framework in order

        // to consider lower rates we set minFps to 0.

        const int minFps = isSetByHwc() ? 0 : mFpsRange.min.getIntValue();

        const int maxFps = mFpsRange.max.getIntValue();



        // Clamp to the range. The current vsyncRate may be outside of this range if the display

        // Clamp to the range. The current refreshRate may be outside of this range if the display

        // has changed its set of supported refresh rates.

        const int displayIntFps = std::clamp(vsyncRate.getIntValue(), minFps, maxFps);

        const int displayIntFps = std::clamp(refreshRate.getIntValue(), minFps, maxFps);

        const int renderIntFps = renderFps.getIntValue();



        // Ensure non-zero range to avoid division by zero.
@@ -260,25 +260,26 @@ void RefreshRateOverlay::setLayerStack(ui::LayerStack stack) { 
    createTransaction().setLayerStack(mSurfaceControl->get(), stack).apply();

}



void RefreshRateOverlay::changeRefreshRate(Fps vsyncRate, Fps renderFps) {

    mVsyncRate = vsyncRate;

void RefreshRateOverlay::changeRefreshRate(Fps refreshRate, Fps renderFps) {

    mRefreshRate = refreshRate;

    mRenderFps = renderFps;

    const auto buffer = getOrCreateBuffers(vsyncRate, renderFps)[mFrame];

    const auto buffer = getOrCreateBuffers(refreshRate, renderFps)[mFrame];

    createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

}



void RefreshRateOverlay::changeRenderRate(Fps renderFps) {

    if (mFeatures.test(Features::RenderRate) && mVsyncRate && FlagManager::getInstance().misc1()) {

    if (mFeatures.test(Features::RenderRate) && mRefreshRate &&

        FlagManager::getInstance().misc1()) {

        mRenderFps = renderFps;

        const auto buffer = getOrCreateBuffers(*mVsyncRate, renderFps)[mFrame];

        const auto buffer = getOrCreateBuffers(*mRefreshRate, renderFps)[mFrame];

        createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

    }

}



void RefreshRateOverlay::animate() {

    if (!mFeatures.test(Features::Spinner) || !mVsyncRate) return;

    if (!mFeatures.test(Features::Spinner) || !mRefreshRate) return;



    const auto& buffers = getOrCreateBuffers(*mVsyncRate, *mRenderFps);

    const auto& buffers = getOrCreateBuffers(*mRefreshRate, *mRenderFps);

    mFrame = (mFrame + 1) % buffers.size();

    const auto buffer = buffers[mFrame];

    createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

services/surfaceflinger/RefreshRateOverlay.h

+3 −3
Original line number Diff line number Diff line
@@ -74,12 +74,12 @@ private: 
    SurfaceComposerClient::Transaction createTransaction() const;



    struct Key {

        int vsyncRate;

        int refreshRate;

        int renderFps;

        ui::Transform::RotationFlags flags;



        bool operator==(Key other) const {

            return vsyncRate == other.vsyncRate && renderFps == other.renderFps &&

            return refreshRate == other.refreshRate && renderFps == other.renderFps &&

                    flags == other.flags;

        }

    };
@@ -87,7 +87,7 @@ private: 
    using BufferCache = ftl::SmallMap<Key, Buffers, 9>;

    BufferCache mBufferCache;



    std::optional<Fps> mVsyncRate;

    std::optional<Fps> mRefreshRate;

    std::optional<Fps> mRenderFps;

    size_t mFrame = 0;