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

Commit 2109270e authored by Vladimir Marko's avatar Vladimir Marko
Browse files

Revert "Second Patch for async RenderEngine" 

Revert "Fix vender implementation due to second patch of async R..."

Revert submission 15644535-asyncRenderEngineV2

Reason for revert: Broke multiple tests
Reverted Changes:
I772122750:Fix vts cases due to function change for async ren...
I615f2927d:Second Patch for async RenderEngine
I3f47b8b67:Fix vender implementation due to second patch of a...

Bug: 202803359
Bug: 202808760
Change-Id: Ib8ef68747621b7114cf2d1dfb856292674729744
parent 403a05bc

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<LayerSettings>& layers,

        const DisplaySettings& display, const std::vector<const 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<LayerSettings>& layers,

        const DisplaySettings& display, const std::vector<const 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 (const auto& layer : layers) {

            if (layer.backgroundBlurRadius > 0) {

        for (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 (const auto& layer : layers) {

    for (auto const 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<LayerSettings>& layers,

                            const std::vector<const 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<LayerSettings>& layers,

            const DisplaySettings& display, const std::vector<const 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<LayerSettings>& layers,

            const DisplaySettings& display, const std::vector<const 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<LayerSettings>&,

                                                 const std::vector<const 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<LayerSettings>&,

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

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

    MOCK_METHOD0(cleanFramebufferCache, void());

    MOCK_METHOD0(getContextPriority, int());