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

Commit 2e9748ff authored by Patrick Williams's avatar Patrick Williams
Browse files

Replace RenderEngineResult with FenceResult 

Bug: b/232535621
Test: atest librenderengine_test
Test: atest SurfaceFlinger_test

Change-Id: If036ab847024751b8da97d6ed856db447db19f6f
parent 4e6f0de7

libs/renderengine/RenderEngine.cpp

+7 −6
Original line number Diff line number Diff line
@@ -63,12 +63,13 @@ void RenderEngine::validateOutputBufferUsage(const sp<GraphicBuffer>& buffer) { 
                        "output buffer not gpu writeable");

}



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

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

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

ftl::Future<FenceResult> RenderEngine::drawLayers(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>>();

    std::future<RenderEngineResult> resultFuture = resultPromise->get_future();

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

    std::future<FenceResult> resultFuture = resultPromise->get_future();

    drawLayersInternal(std::move(resultPromise), display, layers, buffer, useFramebufferCache,

                       std::move(bufferFence));

    return resultFuture;

libs/renderengine/benchmark/RenderEngineBench.cpp

+8 −7
Original line number Diff line number Diff line
@@ -159,9 +159,10 @@ static std::shared_ptr<ExternalTexture> copyBuffer(RenderEngine& re, 
    };

    auto layers = std::vector<LayerSettings>{layer};



    auto [status, drawFence] =

            re.drawLayers(display, layers, texture, kUseFrameBufferCache, base::unique_fd()).get();

    sp<Fence> waitFence = sp<Fence>::make(std::move(drawFence));

    sp<Fence> waitFence =

            re.drawLayers(display, layers, texture, kUseFrameBufferCache, base::unique_fd())

                    .get()

                    .value();

    waitFence->waitForever(LOG_TAG);

    return texture;

}
@@ -190,10 +191,10 @@ static void benchDrawLayers(RenderEngine& re, const std::vector<LayerSettings>& 


    // This loop starts and stops the timer.

    for (auto _ : benchState) {

        auto [status, drawFence] = re.drawLayers(display, layers, outputBuffer,

                                                 kUseFrameBufferCache, base::unique_fd())

                                           .get();

        sp<Fence> waitFence = sp<Fence>::make(std::move(drawFence));

        sp<Fence> waitFence = re.drawLayers(display, layers, outputBuffer, kUseFrameBufferCache,

                                            base::unique_fd())

                                      .get()

                                      .value();

        waitFence->waitForever(LOG_TAG);

    }

libs/renderengine/gl/GLESRenderEngine.cpp

+10 −11
Original line number Diff line number Diff line
@@ -1081,14 +1081,14 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer 
}



void GLESRenderEngine::drawLayersInternal(

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

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

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

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

        base::unique_fd&& bufferFence) {

    ATRACE_CALL();

    if (layers.empty()) {

        ALOGV("Drawing empty layer stack");

        resultPromise->set_value({NO_ERROR, base::unique_fd()});

        resultPromise->set_value(Fence::NO_FENCE);

        return;

    }
@@ -1103,7 +1103,7 @@ void GLESRenderEngine::drawLayersInternal( 


    if (buffer == nullptr) {

        ALOGE("No output buffer provided. Aborting GPU composition.");

        resultPromise->set_value({BAD_VALUE, base::unique_fd()});

        resultPromise->set_value(base::unexpected(BAD_VALUE));

        return;

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

                  buffer->getBuffer()->handle);

            checkErrors();

            resultPromise->set_value({fbo->getStatus(), base::unique_fd()});

            resultPromise->set_value(base::unexpected(fbo->getStatus()));

            return;

        }

        setViewportAndProjection(display.physicalDisplay, display.clip);
@@ -1144,7 +1144,7 @@ void GLESRenderEngine::drawLayersInternal( 
            ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",

                  buffer->getBuffer()->handle);

            checkErrors();

            resultPromise->set_value({status, base::unique_fd()});

            resultPromise->set_value(base::unexpected(status));

            return;

        }

    }
@@ -1178,7 +1178,7 @@ void GLESRenderEngine::drawLayersInternal( 
                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->getBuffer()->handle);

                checkErrors("Can't render first blur pass");

                resultPromise->set_value({status, base::unique_fd()});

                resultPromise->set_value(base::unexpected(status));

                return;

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

                      buffer->getBuffer()->handle);

                checkErrors("Can't bind native framebuffer");

                resultPromise->set_value({status, base::unique_fd()});

                resultPromise->set_value(base::unexpected(status));

                return;

            }
@@ -1210,7 +1210,7 @@ void GLESRenderEngine::drawLayersInternal( 
                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->getBuffer()->handle);

                checkErrors("Can't render blur filter");

                resultPromise->set_value({status, base::unique_fd()});

                resultPromise->set_value(base::unexpected(status));

                return;

            }

        }
@@ -1310,7 +1310,7 @@ void GLESRenderEngine::drawLayersInternal( 
            checkErrors();

            // Chances are, something illegal happened (either the caller passed

            // us bad parameters, or we messed up our shader generation).

            resultPromise->set_value({INVALID_OPERATION, std::move(drawFence)});

            resultPromise->set_value(base::unexpected(INVALID_OPERATION));

            return;

        }

        mLastDrawFence = nullptr;
@@ -1322,8 +1322,7 @@ void GLESRenderEngine::drawLayersInternal( 
    mPriorResourcesCleaned = false;



    checkErrors();

    resultPromise->set_value({NO_ERROR, std::move(drawFence)});

    return;

    resultPromise->set_value(sp<Fence>::make(std::move(drawFence)));

}



void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {

libs/renderengine/gl/GLESRenderEngine.h

+2 −1
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include <renderengine/RenderEngine.h>

#include <renderengine/private/Description.h>

#include <sys/types.h>

#include <ui/FenceResult.h>

#include "GLShadowTexture.h"

#include "ImageManager.h"
@@ -102,7 +103,7 @@ protected: 
            EXCLUDES(mRenderingMutex);

    void unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);

    bool canSkipPostRenderCleanup() const override;

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

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

                            const DisplaySettings& display,

                            const std::vector<LayerSettings>& layers,

                            const std::shared_ptr<ExternalTexture>& buffer,

libs/renderengine/include/renderengine/RenderEngine.h

+10 −15
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#define SF_RENDERENGINE_H_



#include <android-base/unique_fd.h>

#include <ftl/future.h>

#include <math/mat4.h>

#include <renderengine/DisplaySettings.h>

#include <renderengine/ExternalTexture.h>
@@ -26,6 +27,7 @@ 
#include <renderengine/LayerSettings.h>

#include <stdint.h>

#include <sys/types.h>

#include <ui/FenceResult.h>

#include <ui/GraphicTypes.h>

#include <ui/Transform.h>
@@ -68,7 +70,6 @@ class Image; 
class Mesh;

class Texture;

struct RenderEngineCreationArgs;

struct RenderEngineResult;



namespace threaded {

class RenderEngineThreaded;
@@ -158,11 +159,12 @@ public: 
    // parameter does nothing.

    // @param bufferFence Fence signalling that the buffer is ready to be drawn

    // to.

    // @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 std::shared_ptr<ExternalTexture>& buffer, const bool useFramebufferCache,

    // @return A future object of FenceResult indicating whether drawing was

    // successful in async mode.

    virtual ftl::Future<FenceResult> drawLayers(const DisplaySettings& display,

                                                const std::vector<LayerSettings>& layers,

                                                const std::shared_ptr<ExternalTexture>& buffer,

                                                const bool useFramebufferCache,

                                                base::unique_fd&& bufferFence);



    // Clean-up method that should be called on the main thread after the
@@ -237,7 +239,7 @@ protected: 
    const RenderEngineType mRenderEngineType;



    virtual void drawLayersInternal(

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

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

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

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

            base::unique_fd&& bufferFence) = 0;
@@ -327,13 +329,6 @@ private: 
            RenderEngine::RenderEngineType::SKIA_GL_THREADED;

};



struct RenderEngineResult {

    // status indicates if drawing is successful

    status_t status;

    // drawFence will fire when the buffer has been drawn to and is ready to be examined.

    base::unique_fd drawFence;

};



} // namespace renderengine

} // namespace android