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

Commit 59a9f506 authored by Sally Qi's avatar Sally Qi
Browse files

Revert^2 "Second Patch for async RenderEngine" 

Keep the change of Second Patch for async RenderEngine and fix the
regression

- remove the vector variables which is to store futureFence locally in
BufferStateLayer to get avoid fd leaking
- screenshots initiated from the app don't wait on the SF main thread.

2109270e

Bug: 202843200
Bug: 202833127
Bug: 202808760
Test: Wembley PIN setting test, NexusLauncherOutOfProcTests
Change-Id: I87847d01e2e330ddec88272cd8608f0b78c0a2cd
parent 08a97163

libs/renderengine/RenderEngine.cpp

+1 −1
Original line number Diff line number Diff line
@@ -96,7 +96,7 @@ void RenderEngine::validateOutputBufferUsage(const sp<GraphicBuffer>& buffer) { 
}



std::future<RenderEngineResult> RenderEngine::drawLayers(

        const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,

        const DisplaySettings& display, const std::vector<LayerSettings>& layers,

        const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,

        base::unique_fd&& bufferFence) {

    const auto resultPromise = std::make_shared<std::promise<RenderEngineResult>>();

libs/renderengine/gl/GLESRenderEngine.cpp

+33 −33
Original line number Diff line number Diff line
@@ -1080,7 +1080,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer 


void GLESRenderEngine::drawLayersInternal(

        const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,

        const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,

        const DisplaySettings& display, const std::vector<LayerSettings>& layers,

        const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,

        base::unique_fd&& bufferFence) {

    ATRACE_CALL();
@@ -1110,10 +1110,10 @@ void GLESRenderEngine::drawLayersInternal( 
    std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;

    // Gathering layers that requested blur, we'll need them to decide when to render to an

    // offscreen buffer, and when to render to the native buffer.

    std::deque<const LayerSettings*> blurLayers;

    std::deque<const LayerSettings> blurLayers;

    if (CC_LIKELY(mBlurFilter != nullptr)) {

        for (auto layer : layers) {

            if (layer->backgroundBlurRadius > 0) {

        for (const auto& layer : layers) {

            if (layer.backgroundBlurRadius > 0) {

                blurLayers.push_back(layer);

            }

        }
@@ -1137,7 +1137,7 @@ void GLESRenderEngine::drawLayersInternal( 
    } else {

        setViewportAndProjection(display.physicalDisplay, display.clip);

        auto status =

                mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);

                mBlurFilter->setAsDrawTarget(display, blurLayers.front().backgroundBlurRadius);

        if (status != NO_ERROR) {

            ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",

                  buffer->getBuffer()->handle);
@@ -1167,7 +1167,7 @@ void GLESRenderEngine::drawLayersInternal( 
                        .setTexCoords(2 /* size */)

                        .setCropCoords(2 /* size */)

                        .build();

    for (auto const layer : layers) {

    for (const auto& layer : layers) {

        if (blurLayers.size() > 0 && blurLayers.front() == layer) {

            blurLayers.pop_front();
@@ -1193,7 +1193,7 @@ void GLESRenderEngine::drawLayersInternal( 
                // There's still something else to blur, so let's keep rendering to our FBO

                // instead of to the display.

                status = mBlurFilter->setAsDrawTarget(display,

                                                      blurLayers.front()->backgroundBlurRadius);

                                                      blurLayers.front().backgroundBlurRadius);

            }

            if (status != NO_ERROR) {

                ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",
@@ -1214,42 +1214,42 @@ void GLESRenderEngine::drawLayersInternal( 
        }



        // Ensure luminance is at least 100 nits to avoid div-by-zero

        const float maxLuminance = std::max(100.f, layer->source.buffer.maxLuminanceNits);

        const float maxLuminance = std::max(100.f, layer.source.buffer.maxLuminanceNits);

        mState.maxMasteringLuminance = maxLuminance;

        mState.maxContentLuminance = maxLuminance;

        mState.projectionMatrix = projectionMatrix * layer->geometry.positionTransform;

        mState.projectionMatrix = projectionMatrix * layer.geometry.positionTransform;



        const FloatRect bounds = layer->geometry.boundaries;

        const FloatRect bounds = layer.geometry.boundaries;

        Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());

        position[0] = vec2(bounds.left, bounds.top);

        position[1] = vec2(bounds.left, bounds.bottom);

        position[2] = vec2(bounds.right, bounds.bottom);

        position[3] = vec2(bounds.right, bounds.top);



        setupLayerCropping(*layer, mesh);

        setColorTransform(layer->colorTransform);

        setupLayerCropping(layer, mesh);

        setColorTransform(layer.colorTransform);



        bool usePremultipliedAlpha = true;

        bool disableTexture = true;

        bool isOpaque = false;

        if (layer->source.buffer.buffer != nullptr) {

        if (layer.source.buffer.buffer != nullptr) {

            disableTexture = false;

            isOpaque = layer->source.buffer.isOpaque;

            isOpaque = layer.source.buffer.isOpaque;



            sp<GraphicBuffer> gBuf = layer->source.buffer.buffer->getBuffer();

            sp<GraphicBuffer> gBuf = layer.source.buffer.buffer->getBuffer();

            validateInputBufferUsage(gBuf);

            bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,

                                      layer->source.buffer.fence);

            bindExternalTextureBuffer(layer.source.buffer.textureName, gBuf,

                                      layer.source.buffer.fence);



            usePremultipliedAlpha = layer->source.buffer.usePremultipliedAlpha;

            Texture texture(Texture::TEXTURE_EXTERNAL, layer->source.buffer.textureName);

            mat4 texMatrix = layer->source.buffer.textureTransform;

            usePremultipliedAlpha = layer.source.buffer.usePremultipliedAlpha;

            Texture texture(Texture::TEXTURE_EXTERNAL, layer.source.buffer.textureName);

            mat4 texMatrix = layer.source.buffer.textureTransform;



            texture.setMatrix(texMatrix.asArray());

            texture.setFiltering(layer->source.buffer.useTextureFiltering);

            texture.setFiltering(layer.source.buffer.useTextureFiltering);



            texture.setDimensions(gBuf->getWidth(), gBuf->getHeight());

            setSourceY410BT2020(layer->source.buffer.isY410BT2020);

            setSourceY410BT2020(layer.source.buffer.isY410BT2020);



            renderengine::Mesh::VertexArray<vec2> texCoords(mesh.getTexCoordArray<vec2>());

            texCoords[0] = vec2(0.0, 0.0);
@@ -1264,32 +1264,32 @@ void GLESRenderEngine::drawLayersInternal( 
            }

        }



        const half3 solidColor = layer->source.solidColor;

        const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer->alpha);

        const half3 solidColor = layer.source.solidColor;

        const half4 color = half4(solidColor.r, solidColor.g, solidColor.b, layer.alpha);

        // Buffer sources will have a black solid color ignored in the shader,

        // so in that scenario the solid color passed here is arbitrary.

        setupLayerBlending(usePremultipliedAlpha, isOpaque, disableTexture, color,

                           layer->geometry.roundedCornersRadius);

        if (layer->disableBlending) {

                           layer.geometry.roundedCornersRadius);

        if (layer.disableBlending) {

            glDisable(GL_BLEND);

        }

        setSourceDataSpace(layer->sourceDataspace);

        setSourceDataSpace(layer.sourceDataspace);



        if (layer->shadow.length > 0.0f) {

            handleShadow(layer->geometry.boundaries, layer->geometry.roundedCornersRadius,

                         layer->shadow);

        if (layer.shadow.length > 0.0f) {

            handleShadow(layer.geometry.boundaries, layer.geometry.roundedCornersRadius,

                         layer.shadow);

        }

        // We only want to do a special handling for rounded corners when having rounded corners

        // is the only reason it needs to turn on blending, otherwise, we handle it like the

        // usual way since it needs to turn on blending anyway.

        else if (layer->geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {

            handleRoundedCorners(display, *layer, mesh);

        else if (layer.geometry.roundedCornersRadius > 0.0 && color.a >= 1.0f && isOpaque) {

            handleRoundedCorners(display, layer, mesh);

        } else {

            drawMesh(mesh);

        }



        // Cleanup if there's a buffer source

        if (layer->source.buffer.buffer != nullptr) {

        if (layer.source.buffer.buffer != nullptr) {

            disableBlending();

            setSourceY410BT2020(false);

            disableTexturing();

libs/renderengine/gl/GLESRenderEngine.h

+1 −1
Original line number Diff line number Diff line
@@ -104,7 +104,7 @@ protected: 
    bool canSkipPostRenderCleanup() const override;

    void drawLayersInternal(const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,

                            const DisplaySettings& display,

                            const std::vector<const LayerSettings*>& layers,

                            const std::vector<LayerSettings>& layers,

                            const std::shared_ptr<ExternalTexture>& buffer,

                            const bool useFramebufferCache, base::unique_fd&& bufferFence) override;

libs/renderengine/include/renderengine/RenderEngine.h

+2 −2
Original line number Diff line number Diff line
@@ -160,7 +160,7 @@ public: 
    // @return A future object of RenderEngineResult struct indicating whether

    // drawing was successful in async mode.

    virtual std::future<RenderEngineResult> drawLayers(

            const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,

            const DisplaySettings& display, const std::vector<LayerSettings>& layers,

            const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,

            base::unique_fd&& bufferFence);
@@ -231,7 +231,7 @@ protected: 


    virtual void drawLayersInternal(

            const std::shared_ptr<std::promise<RenderEngineResult>>&& resultPromise,

            const DisplaySettings& display, const std::vector<const LayerSettings*>& layers,

            const DisplaySettings& display, const std::vector<LayerSettings>& layers,

            const std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,

            base::unique_fd&& bufferFence) = 0;

};

libs/renderengine/include/renderengine/mock/RenderEngine.h

+2 −2
Original line number Diff line number Diff line
@@ -49,12 +49,12 @@ public: 
    MOCK_CONST_METHOD0(canSkipPostRenderCleanup, bool());

    MOCK_METHOD5(drawLayers,

                 std::future<RenderEngineResult>(const DisplaySettings&,

                                                 const std::vector<const LayerSettings*>&,

                                                 const std::vector<LayerSettings>&,

                                                 const std::shared_ptr<ExternalTexture>&,

                                                 const bool, base::unique_fd&&));

    MOCK_METHOD6(drawLayersInternal,

                 void(const std::shared_ptr<std::promise<RenderEngineResult>>&&,

                      const DisplaySettings&, const std::vector<const LayerSettings*>&,

                      const DisplaySettings&, const std::vector<LayerSettings>&,

                      const std::shared_ptr<ExternalTexture>&, const bool, base::unique_fd&&));

    MOCK_METHOD0(cleanFramebufferCache, void());

    MOCK_METHOD0(getContextPriority, int());