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

Commit 3348c74c authored by Russell Myers's avatar Russell Myers
Browse files

Create more expressive shader cache config. 

Devices such as Wear and others may not need one of the many portions of
the cache that are available by default. Rather than simply configuring
just HDR and / or the entire cache, we offer a more nuanced
configuration that can be turned off via system properties.

Bug: 325045840
Test: Local wear builds with different configuration settings.
Change-Id: I0aded11eeab45d3684979f24c12f3676deb6d27b
parent 4994e61d

libs/renderengine/include/renderengine/RenderEngine.h

+16 −1
Original line number Diff line number Diff line
@@ -88,6 +88,21 @@ enum class Protection { 
    PROTECTED = 2,

};



// Toggles for skipping or enabling priming of particular shaders.

struct PrimeCacheConfig {

    bool cacheHolePunchLayer = true;

    bool cacheSolidLayers = true;

    bool cacheSolidDimmedLayers = true;

    bool cacheImageLayers = true;

    bool cacheImageDimmedLayers = true;

    bool cacheClippedLayers = true;

    bool cacheShadowLayers = true;

    bool cachePIPImageLayers = true;

    bool cacheTransparentImageDimmedLayers = true;

    bool cacheClippedDimmedImageLayers = true;

    bool cacheUltraHDR = true;

};



class RenderEngine {

public:

    enum class ContextPriority {
@@ -145,7 +160,7 @@ public: 
    // This interface, while still in use until a suitable replacement is built,

    // should be considered deprecated, minus some methods which still may be

    // used to support legacy behavior.

    virtual std::future<void> primeCache(bool shouldPrimeUltraHDR) = 0;

    virtual std::future<void> primeCache(PrimeCacheConfig config) = 0;



    // dump the extension strings. always call the base class.

    virtual void dump(std::string& result) = 0;

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

+1 −1
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ public: 
    RenderEngine();

    ~RenderEngine() override;



    MOCK_METHOD1(primeCache, std::future<void>(bool));

    MOCK_METHOD1(primeCache, std::future<void>(PrimeCacheConfig));

    MOCK_METHOD1(dump, void(std::string&));

    MOCK_CONST_METHOD0(getMaxTextureSize, size_t());

    MOCK_CONST_METHOD0(getMaxViewportDims, size_t());

libs/renderengine/skia/Cache.cpp

+45 −21
Original line number Diff line number Diff line
@@ -630,7 +630,7 @@ static void drawP3ImageLayers(SkiaRenderEngine* renderengine, const DisplaySetti 
//    kFlushAfterEveryLayer = true

// in external/skia/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp

//    gPrintSKSL = true

void Cache::primeShaderCache(SkiaRenderEngine* renderengine, bool shouldPrimeUltraHDR) {

void Cache::primeShaderCache(SkiaRenderEngine* renderengine, PrimeCacheConfig config) {

    const int previousCount = renderengine->reportShadersCompiled();

    if (previousCount) {

        ALOGD("%d Shaders already compiled before Cache::primeShaderCache ran\n", previousCount);
@@ -694,13 +694,24 @@ void Cache::primeShaderCache(SkiaRenderEngine* renderengine, bool shouldPrimeUlt 
                impl::ExternalTexture>(srcBuffer, *renderengine,

                                       impl::ExternalTexture::Usage::READABLE |

                                               impl::ExternalTexture::Usage::WRITEABLE);



        if (config.cacheHolePunchLayer) {

            drawHolePunchLayer(renderengine, display, dstTexture);

        }



        if (config.cacheSolidLayers) {

            drawSolidLayers(renderengine, display, dstTexture);

            drawSolidLayers(renderengine, p3Display, dstTexture);

        }



        if (config.cacheSolidDimmedLayers) {

            drawSolidDimmedLayers(renderengine, display, dstTexture);

        }



        if (config.cacheShadowLayers) {

            drawShadowLayers(renderengine, display, srcTexture);

            drawShadowLayers(renderengine, p3Display, srcTexture);

        }



        if (renderengine->supportsBackgroundBlur()) {

            drawBlurLayers(renderengine, display, dstTexture);
@@ -737,27 +748,40 @@ void Cache::primeShaderCache(SkiaRenderEngine* renderengine, bool shouldPrimeUlt 
        }



        for (auto texture : textures) {

            if (config.cacheImageLayers) {

                drawImageLayers(renderengine, display, dstTexture, texture);

            }



            if (config.cacheImageDimmedLayers) {

                drawImageDimmedLayers(renderengine, display, dstTexture, texture);

                drawImageDimmedLayers(renderengine, p3Display, dstTexture, texture);

                drawImageDimmedLayers(renderengine, bt2020Display, dstTexture, texture);

            }



            if (config.cacheClippedLayers) {

                // Draw layers for b/185569240.

                drawClippedLayers(renderengine, display, dstTexture, texture);

            }

        }



        if (config.cachePIPImageLayers) {

            drawPIPImageLayer(renderengine, display, dstTexture, externalTexture);

        }



        drawTransparentImageDimmedLayers(renderengine, bt2020Display, dstTexture, externalTexture);

        if (config.cacheTransparentImageDimmedLayers) {

            drawTransparentImageDimmedLayers(renderengine, bt2020Display, dstTexture,

                                             externalTexture);

            drawTransparentImageDimmedLayers(renderengine, display, dstTexture, externalTexture);

            drawTransparentImageDimmedLayers(renderengine, p3Display, dstTexture, externalTexture);

            drawTransparentImageDimmedLayers(renderengine, p3DisplayEnhance, dstTexture,

                                             externalTexture);

        }



        if (config.cacheClippedDimmedImageLayers) {

            drawClippedDimmedImageLayers(renderengine, bt2020Display, dstTexture, externalTexture);

        }



        if (shouldPrimeUltraHDR) {

        if (config.cacheUltraHDR) {

            drawBT2020ClippedImageLayers(renderengine, bt2020Display, dstTexture, externalTexture);



            drawBT2020ImageLayers(renderengine, bt2020Display, dstTexture, externalTexture);

libs/renderengine/skia/Cache.h

+8 −3
Original line number Diff line number Diff line
@@ -16,16 +16,21 @@ 


#pragma once



namespace android::renderengine::skia {

namespace android::renderengine {



struct PrimeCacheConfig;



namespace skia {



class SkiaRenderEngine;



class Cache {

public:

    static void primeShaderCache(SkiaRenderEngine*, bool shouldPrimeUltraHDR);

    static void primeShaderCache(SkiaRenderEngine*, PrimeCacheConfig config);



private:

    Cache() = default;

};



} // namespace android::renderengine::skia
 
} // namespace skia

} // namespace android::renderengine

libs/renderengine/skia/SkiaRenderEngine.cpp

+2 −2
Original line number Diff line number Diff line
@@ -246,8 +246,8 @@ namespace skia { 


using base::StringAppendF;



std::future<void> SkiaRenderEngine::primeCache(bool shouldPrimeUltraHDR) {

    Cache::primeShaderCache(this, shouldPrimeUltraHDR);

std::future<void> SkiaRenderEngine::primeCache(PrimeCacheConfig config) {

    Cache::primeShaderCache(this, config);

    return {};

}