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

Commit f11eba5d authored by Lucas Dupin's avatar Lucas Dupin
Browse files

Do not blur when doing region sampling 

The luma approximation will already be pretty good without the blurs.

Test: RegionSamplingTest
Test: libsurfacelfinger_test
Fixes: 154556259
Change-Id: I4010ac54aee2e23bd8cf155f591584eeec425702
Merged-In: I4010ac54aee2e23bd8cf155f591584eeec425702
parent 85c2ee61

services/surfaceflinger/RegionSamplingThread.cpp

+2 −1
Original line number Original line Diff line number Diff line
@@ -430,7 +430,8 @@ void RegionSamplingThread::captureSample() { 
    }

    }





    bool ignored;

    bool ignored;

    mFlinger.captureScreenCommon(renderArea, traverseLayers, buffer, false, ignored);

    mFlinger.captureScreenCommon(renderArea, traverseLayers, buffer, false /* identityTransform */,

                                 true /* regionSampling */, ignored);





    std::vector<Descriptor> activeDescriptors;

    std::vector<Descriptor> activeDescriptors;

    for (const auto& descriptor : descriptors) {

    for (const auto& descriptor : descriptors) {

services/surfaceflinger/SurfaceFlinger.cpp

+14 −6
Original line number Original line Diff line number Diff line
@@ -5665,13 +5665,13 @@ status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea, 
                                             usage, "screenshot");

                                             usage, "screenshot");





    return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,

    return captureScreenCommon(renderArea, traverseLayers, *outBuffer, useIdentityTransform,

                               outCapturedSecureLayers);

                               false /* regionSampling */, outCapturedSecureLayers);

}

}





status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,

status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea,

                                             TraverseLayersFunction traverseLayers,

                                             TraverseLayersFunction traverseLayers,

                                             const sp<GraphicBuffer>& buffer,

                                             const sp<GraphicBuffer>& buffer,

                                             bool useIdentityTransform,

                                             bool useIdentityTransform, bool regionSampling,

                                             bool& outCapturedSecureLayers) {

                                             bool& outCapturedSecureLayers) {

    // This mutex protects syncFd and captureResult for communication of the return values from the

    // This mutex protects syncFd and captureResult for communication of the return values from the

    // main thread back to this Binder thread

    // main thread back to this Binder thread
@@ -5702,7 +5702,7 @@ status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea, 
            renderArea.render([&] {

            renderArea.render([&] {

                result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),

                result = captureScreenImplLocked(renderArea, traverseLayers, buffer.get(),

                                                 useIdentityTransform, forSystem, &fd,

                                                 useIdentityTransform, forSystem, &fd,

                                                 outCapturedSecureLayers);

                                                 regionSampling, outCapturedSecureLayers);

            });

            });

        }

        }
@@ -5739,7 +5739,7 @@ status_t SurfaceFlinger::captureScreenCommon(RenderArea& renderArea, 
void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,

void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea,

                                            TraverseLayersFunction traverseLayers,

                                            TraverseLayersFunction traverseLayers,

                                            ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                            ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                            int* outSyncFd) {

                                            bool regionSampling, int* outSyncFd) {

    ATRACE_CALL();

    ATRACE_CALL();





    const auto reqWidth = renderArea.getReqWidth();

    const auto reqWidth = renderArea.getReqWidth();
@@ -5795,6 +5795,12 @@ void SurfaceFlinger::renderScreenImplLocked(const RenderArea& renderArea, 
            for (auto& settings : results) {

            for (auto& settings : results) {

                settings.geometry.positionTransform =

                settings.geometry.positionTransform =

                        transform.asMatrix4() * settings.geometry.positionTransform;

                        transform.asMatrix4() * settings.geometry.positionTransform;

                // There's no need to process blurs when we're executing region sampling,

                // we're just trying to understand what we're drawing, and doing so without

                // blurs is already a pretty good approximation.

                if (regionSampling) {

                    settings.backgroundBlurRadius = 0;

                }

            }

            }

            clientCompositionLayers.insert(clientCompositionLayers.end(),

            clientCompositionLayers.insert(clientCompositionLayers.end(),

                                           std::make_move_iterator(results.begin()),

                                           std::make_move_iterator(results.begin()),
@@ -5832,7 +5838,8 @@ status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea, 
                                                 TraverseLayersFunction traverseLayers,

                                                 TraverseLayersFunction traverseLayers,

                                                 ANativeWindowBuffer* buffer,

                                                 ANativeWindowBuffer* buffer,

                                                 bool useIdentityTransform, bool forSystem,

                                                 bool useIdentityTransform, bool forSystem,

                                                 int* outSyncFd, bool& outCapturedSecureLayers) {

                                                 int* outSyncFd, bool regionSampling,

                                                 bool& outCapturedSecureLayers) {

    ATRACE_CALL();

    ATRACE_CALL();





    traverseLayers([&](Layer* layer) {

    traverseLayers([&](Layer* layer) {
@@ -5847,7 +5854,8 @@ status_t SurfaceFlinger::captureScreenImplLocked(const RenderArea& renderArea, 
        ALOGW("FB is protected: PERMISSION_DENIED");

        ALOGW("FB is protected: PERMISSION_DENIED");

        return PERMISSION_DENIED;

        return PERMISSION_DENIED;

    }

    }

    renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, outSyncFd);

    renderScreenImplLocked(renderArea, traverseLayers, buffer, useIdentityTransform, regionSampling,

                           outSyncFd);

    return NO_ERROR;

    return NO_ERROR;

}

}

services/surfaceflinger/SurfaceFlinger.h

+4 −3
Original line number Original line Diff line number Diff line
@@ -697,19 +697,20 @@ private: 




    void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,

    void renderScreenImplLocked(const RenderArea& renderArea, TraverseLayersFunction traverseLayers,

                                ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                int* outSyncFd);

                                bool regionSampling, int* outSyncFd);

    status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,

    status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,

                                 sp<GraphicBuffer>* outBuffer, const ui::PixelFormat reqPixelFormat,

                                 sp<GraphicBuffer>* outBuffer, const ui::PixelFormat reqPixelFormat,

                                 bool useIdentityTransform, bool& outCapturedSecureLayers);

                                 bool useIdentityTransform, bool& outCapturedSecureLayers);

    status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,

    status_t captureScreenCommon(RenderArea& renderArea, TraverseLayersFunction traverseLayers,

                                 const sp<GraphicBuffer>& buffer, bool useIdentityTransform,

                                 const sp<GraphicBuffer>& buffer, bool useIdentityTransform,

                                 bool& outCapturedSecureLayers);

                                 bool regionSampling, bool& outCapturedSecureLayers);

    const sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack);

    const sp<DisplayDevice> getDisplayByIdOrLayerStack(uint64_t displayOrLayerStack);

    const sp<DisplayDevice> getDisplayByLayerStack(uint64_t layerStack);

    const sp<DisplayDevice> getDisplayByLayerStack(uint64_t layerStack);

    status_t captureScreenImplLocked(const RenderArea& renderArea,

    status_t captureScreenImplLocked(const RenderArea& renderArea,

                                     TraverseLayersFunction traverseLayers,

                                     TraverseLayersFunction traverseLayers,

                                     ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                     ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                     bool forSystem, int* outSyncFd, bool& outCapturedSecureLayers);

                                     bool forSystem, int* outSyncFd, bool regionSampling,

                                     bool& outCapturedSecureLayers);

    void traverseLayersInDisplay(const sp<const DisplayDevice>& display,

    void traverseLayersInDisplay(const sp<const DisplayDevice>& display,

                                 const LayerVector::Visitor& visitor);

                                 const LayerVector::Visitor& visitor);

services/surfaceflinger/tests/unittests/CompositionTest.cpp

+2 −1
Original line number Original line Diff line number Diff line
@@ -231,6 +231,7 @@ void CompositionTest::captureScreenComposition() { 
    const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);

    const Rect sourceCrop(0, 0, DEFAULT_DISPLAY_WIDTH, DEFAULT_DISPLAY_HEIGHT);

    constexpr bool useIdentityTransform = true;

    constexpr bool useIdentityTransform = true;

    constexpr bool forSystem = true;

    constexpr bool forSystem = true;

    constexpr bool regionSampling = false;





    DisplayRenderArea renderArea(mDisplay, sourceCrop, DEFAULT_DISPLAY_WIDTH,

    DisplayRenderArea renderArea(mDisplay, sourceCrop, DEFAULT_DISPLAY_WIDTH,

                                 DEFAULT_DISPLAY_HEIGHT, ui::Dataspace::V0_SRGB,

                                 DEFAULT_DISPLAY_HEIGHT, ui::Dataspace::V0_SRGB,
@@ -249,7 +250,7 @@ void CompositionTest::captureScreenComposition() { 
    int fd = -1;

    int fd = -1;

    status_t result =

    status_t result =

            mFlinger.captureScreenImplLocked(renderArea, traverseLayers, mCaptureScreenBuffer.get(),

            mFlinger.captureScreenImplLocked(renderArea, traverseLayers, mCaptureScreenBuffer.get(),

                                             useIdentityTransform, forSystem, &fd);

                                             useIdentityTransform, forSystem, &fd, regionSampling);

    if (fd >= 0) {

    if (fd >= 0) {

        close(fd);

        close(fd);

    }

    }

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+5 −4
Original line number Original line Diff line number Diff line
@@ -323,13 +323,14 @@ public: 




    auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what, systemTime()); }

    auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what, systemTime()); }





    auto captureScreenImplLocked(

    auto captureScreenImplLocked(const RenderArea& renderArea,

            const RenderArea& renderArea, SurfaceFlinger::TraverseLayersFunction traverseLayers,

                                 SurfaceFlinger::TraverseLayersFunction traverseLayers,

            ANativeWindowBuffer* buffer, bool useIdentityTransform, bool forSystem, int* outSyncFd) {

                                 ANativeWindowBuffer* buffer, bool useIdentityTransform,

                                 bool forSystem, int* outSyncFd, bool regionSampling) {

        bool ignored;

        bool ignored;

        return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,

        return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,

                                                 useIdentityTransform, forSystem, outSyncFd,

                                                 useIdentityTransform, forSystem, outSyncFd,

                                                 ignored);

                                                 regionSampling, ignored);

    }

    }





    auto traverseLayersInDisplay(const sp<const DisplayDevice>& display,

    auto traverseLayersInDisplay(const sp<const DisplayDevice>& display,