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

Commit f29700fb authored by Alec Mouri's avatar Alec Mouri
Browse files

Remove useFramebufferCache parameter in drawLayers() 

GLESRenderEngine used it, but GLESRenderEngine is no more.

Bug: 199918329
Test: builds
Change-Id: Id4fcc15d802523faa548ccea0bbd94cffea1b272
parent 9af38ba9

libs/renderengine/RenderEngine.cpp

+1 −3
Original line number Diff line number Diff line
@@ -68,13 +68,11 @@ void RenderEngine::validateOutputBufferUsage(const sp<GraphicBuffer>& buffer) { 
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<FenceResult>>();

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

    updateProtectedContext(layers, buffer);

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

                       std::move(bufferFence));

    drawLayersInternal(std::move(resultPromise), display, layers, buffer, std::move(bufferFence));

    return resultFuture;

}

libs/renderengine/benchmark/RenderEngineBench.cpp

+3 −12
Original line number Diff line number Diff line
@@ -104,10 +104,6 @@ std::pair<uint32_t, uint32_t> getDisplaySize() { 
    return std::pair<uint32_t, uint32_t>(width, height);

}



// This value doesn't matter, as it's not read. TODO(b/199918329): Once we remove

// GLESRenderEngine we can remove this, too.

static constexpr const bool kUseFrameBufferCache = false;



static std::unique_ptr<RenderEngine> createRenderEngine(RenderEngine::RenderEngineType type) {

    auto args = RenderEngineCreationArgs::Builder()

                        .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))
@@ -168,10 +164,7 @@ static std::shared_ptr<ExternalTexture> copyBuffer(RenderEngine& re, 
    };

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



    sp<Fence> waitFence =

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

                    .get()

                    .value();

    sp<Fence> waitFence = re.drawLayers(display, layers, texture, base::unique_fd()).get().value();

    waitFence->waitForever(LOG_TAG);

    return texture;

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


    // This loop starts and stops the timer.

    for (auto _ : benchState) {

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

                                            base::unique_fd())

                                      .get()

                                      .value();

        sp<Fence> waitFence =

                re.drawLayers(display, layers, outputBuffer, base::unique_fd()).get().value();

        waitFence->waitForever(LOG_TAG);

    }

libs/renderengine/include/renderengine/RenderEngine.h

+1 −6
Original line number Diff line number Diff line
@@ -145,9 +145,6 @@ public: 
    // @param layers The layers to draw onto the display, in Z-order.

    // @param buffer The buffer which will be drawn to. This buffer will be

    // ready once drawFence fires.

    // @param useFramebufferCache True if the framebuffer cache should be used.

    // If an implementation does not cache output framebuffers, then this

    // parameter does nothing.

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

    // to.

    // @return A future object of FenceResult indicating whether drawing was
@@ -155,7 +152,6 @@ public: 
    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
@@ -244,8 +240,7 @@ protected: 
    virtual void drawLayersInternal(

            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;

            const std::shared_ptr<ExternalTexture>& buffer, base::unique_fd&& bufferFence) = 0;

};



struct RenderEngineCreationArgs {

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

+4 −4
Original line number Diff line number Diff line
@@ -42,14 +42,14 @@ public: 
    MOCK_METHOD1(useProtectedContext, void(bool));

    MOCK_METHOD0(cleanupPostRender, void());

    MOCK_CONST_METHOD0(canSkipPostRenderCleanup, bool());

    MOCK_METHOD5(drawLayers,

    MOCK_METHOD4(drawLayers,

                 ftl::Future<FenceResult>(const DisplaySettings&, const std::vector<LayerSettings>&,

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

                                          const std::shared_ptr<ExternalTexture>&,

                                          base::unique_fd&&));

    MOCK_METHOD6(drawLayersInternal,

    MOCK_METHOD5(drawLayersInternal,

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

                      const std::vector<LayerSettings>&, const std::shared_ptr<ExternalTexture>&,

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

                      base::unique_fd&&));

    MOCK_METHOD0(getContextPriority, int());

    MOCK_METHOD0(supportsBackgroundBlur, bool());

    MOCK_METHOD1(onActiveDisplaySizeChanged, void(ui::Size));

libs/renderengine/skia/Cache.cpp

+8 −17
Original line number Diff line number Diff line
@@ -29,8 +29,6 @@ 
namespace android::renderengine::skia {



namespace {

// Warming shader cache, not framebuffer cache.

constexpr bool kUseFrameBufferCache = false;



// clang-format off

// Any non-identity matrix will do.
@@ -116,8 +114,7 @@ static void drawShadowLayers(SkiaRenderEngine* renderengine, const DisplaySettin 
        caster.geometry.positionTransform = transform;



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

        renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,

                                 base::unique_fd());

        renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

    }

}
@@ -154,8 +151,7 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
                for (auto alpha : {half(.2f), half(1.0f)}) {

                    layer.alpha = alpha;

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

                    renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,

                                             base::unique_fd());

                    renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

                }

            }

        }
@@ -183,8 +179,7 @@ static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
        for (float roundedCornersRadius : {0.0f, 50.f}) {

            layer.geometry.roundedCornersRadius = {roundedCornersRadius, roundedCornersRadius};

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

            renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,

                                     base::unique_fd());

            renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

        }

    }

}
@@ -207,8 +202,7 @@ static void drawBlurLayers(SkiaRenderEngine* renderengine, const DisplaySettings 
    for (int radius : {9, 60}) {

        layer.backgroundBlurRadius = radius;

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

        renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,

                                 base::unique_fd());

        renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

    }

}
@@ -254,8 +248,7 @@ static void drawClippedLayers(SkiaRenderEngine* renderengine, const DisplaySetti 
                for (float alpha : {0.5f, 1.f}) {

                    layer.alpha = alpha;

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

                    renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache,

                                             base::unique_fd());

                    renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

                }

            }

        }
@@ -292,7 +285,7 @@ static void drawPIPImageLayer(SkiaRenderEngine* renderengine, const DisplaySetti 
    };



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

    renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache, base::unique_fd());

    renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

}



static void drawHolePunchLayer(SkiaRenderEngine* renderengine, const DisplaySettings& display,
@@ -321,7 +314,7 @@ static void drawHolePunchLayer(SkiaRenderEngine* renderengine, const DisplaySett 
    };



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

    renderengine->drawLayers(display, layers, dstTexture, kUseFrameBufferCache, base::unique_fd());

    renderengine->drawLayers(display, layers, dstTexture, base::unique_fd());

}



//
@@ -436,9 +429,7 @@ void Cache::primeShaderCache(SkiaRenderEngine* renderengine) { 
        };

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

        // call get() to make it synchronous

        renderengine

                ->drawLayers(display, layers, dstTexture, kUseFrameBufferCache, base::unique_fd())

                .get();

        renderengine->drawLayers(display, layers, dstTexture, base::unique_fd()).get();



        const nsecs_t timeAfter = systemTime();

        const float compileTimeMs = static_cast<float>(timeAfter - timeBefore) / 1.0E6;