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

Commit f06a45ba authored by Nathaniel Nifong's avatar Nathaniel Nifong
Browse files

Cache shaders having useIsOpaqueWorkaround 

Test: Confirm shaders generated, and no cache misses on maps open/close

Bug: b/191439967

run every combo of texture, external texture, and external texture with
F16 color type with both regular image layers and specially clipped
image layers.

Change-Id: I7649cdb4f19d7c7d8713f016ed77c91cbc60a38d
parent 2bd3639d

libs/renderengine/skia/Cache.cpp

+28 −33
Original line number Original line Diff line number Diff line
@@ -99,6 +99,9 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
    LayerSettings layer{

    LayerSettings layer{

            .geometry =

            .geometry =

                    Geometry{

                    Geometry{

                            // The position transform doesn't matter when the reduced shader mode

                            // in in effect. A matrix transform stage is always included.

                            .positionTransform = mat4(),

                            .boundaries = rect,

                            .boundaries = rect,

                            .roundedCornersCrop = rect,

                            .roundedCornersCrop = rect,

                    },

                    },
@@ -109,25 +112,15 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
                                          }},

                                          }},

    };

    };





    auto threeCornerRadii = {0.0f, 0.05f, 50.f};

    auto oneCornerRadius = {50.f};



    // Test both drawRect and drawRRect

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

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

    for (auto dataspace : {kDestDataSpace, kOtherDataSpace}) {

    for (auto dataspace : {kDestDataSpace, kOtherDataSpace}) {

        layer.sourceDataspace = dataspace;

        layer.sourceDataspace = dataspace;

        for (bool identity : {true, false}) {

        for (float roundedCornersRadius : {0.0f, 50.0f}) {

            layer.geometry.positionTransform = identity ? mat4() : kScaleAndTranslate;

            // roundedCornersCrop is always set, but the radius triggers the behavior

            // Corner radii less than 0.5 creates a special shader. This likely occurs in real usage

            // due to animating corner radius.

            // For the non-idenity matrix, only the large corner radius will create a new shader.

            for (float roundedCornersRadius : identity ? threeCornerRadii : oneCornerRadius) {

                // roundedCornersCrop is always set, but it is this radius that triggers the

                // behavior

            layer.geometry.roundedCornersRadius = roundedCornersRadius;

            layer.geometry.roundedCornersRadius = roundedCornersRadius;

            for (bool isOpaque : {true, false}) {

            for (bool isOpaque : {true, false}) {

                layer.source.buffer.isOpaque = isOpaque;

                layer.source.buffer.isOpaque = isOpaque;

                    for (auto alpha : {half(.23999f), half(1.0f)}) {

                for (auto alpha : {half(.2f), half(1.0f)}) {

                    layer.alpha = alpha;

                    layer.alpha = alpha;

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

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

                                             base::unique_fd(), nullptr);

                                             base::unique_fd(), nullptr);
@@ -136,7 +129,6 @@ static void drawImageLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
        }

        }

    }

    }

}

}

}





static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySettings& display,

static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySettings& display,

                            const std::shared_ptr<ExternalTexture>& dstTexture) {

                            const std::shared_ptr<ExternalTexture>& dstTexture) {
@@ -157,7 +149,7 @@ static void drawSolidLayers(SkiaRenderEngine* renderengine, const DisplaySetting 
    auto layers = std::vector<const LayerSettings*>{&layer};

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

    for (auto transform : {mat4(), kScaleAndTranslate}) {

    for (auto transform : {mat4(), kScaleAndTranslate}) {

        layer.geometry.positionTransform = transform;

        layer.geometry.positionTransform = transform;

        for (float roundedCornersRadius : {0.0f, 0.05f, 50.f}) {

        for (float roundedCornersRadius : {0.0f, 50.f}) {

            layer.geometry.roundedCornersRadius = roundedCornersRadius;

            layer.geometry.roundedCornersRadius = roundedCornersRadius;

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

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

                                     base::unique_fd(), nullptr);

                                     base::unique_fd(), nullptr);
@@ -295,34 +287,37 @@ void Cache::primeShaderCache(SkiaRenderEngine* renderengine) { 
                                                  ExternalTexture::Usage::READABLE |

                                                  ExternalTexture::Usage::READABLE |

                                                          ExternalTexture::Usage::WRITEABLE);

                                                          ExternalTexture::Usage::WRITEABLE);





        // 6 shaders

        drawSolidLayers(renderengine, display, dstTexture);

        drawSolidLayers(renderengine, display, dstTexture);

        // 8 shaders

        drawShadowLayers(renderengine, display, srcTexture);

        drawShadowLayers(renderengine, display, srcTexture);





        if (renderengine->supportsBackgroundBlur()) {

        if (renderengine->supportsBackgroundBlur()) {

            // 2 shaders

            drawBlurLayers(renderengine, display, dstTexture);

            drawBlurLayers(renderengine, display, dstTexture);

        }

        }





        // The majority of shaders are related to sampling images.

        drawImageLayers(renderengine, display, dstTexture, srcTexture);



        // should be the same as AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;

        // should be the same as AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;

        const int64_t usageExternal = GRALLOC_USAGE_HW_TEXTURE;

        const int64_t usageExternal = GRALLOC_USAGE_HW_TEXTURE;



        sp<GraphicBuffer> externalBuffer =

        sp<GraphicBuffer> externalBuffer =

                new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_8888,

                new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_8888,

                                  1, usageExternal, "primeShaderCache_external");

                                  1, usageExternal, "primeShaderCache_external");

        const auto externalTexture =

        const auto externalTexture =

                std::make_shared<ExternalTexture>(externalBuffer, *renderengine,

                std::make_shared<ExternalTexture>(externalBuffer, *renderengine,

                                                  ExternalTexture::Usage::READABLE);

                                                  ExternalTexture::Usage::READABLE);

        // TODO(b/184665179) doubles number of image shader compilations, but only somewhere

        // between 6 and 8 will occur in real uses.

        drawImageLayers(renderengine, display, dstTexture, externalTexture);





        // Another external texture with a different pixel format triggers useIsOpaqueWorkaround

        sp<GraphicBuffer> f16ExternalBuffer =

                new GraphicBuffer(displayRect.width(), displayRect.height(), PIXEL_FORMAT_RGBA_FP16,

                                  1, usageExternal, "primeShaderCache_external_f16");

        const auto f16ExternalTexture =

                std::make_shared<ExternalTexture>(f16ExternalBuffer, *renderengine,

                                                  ExternalTexture::Usage::READABLE);



        // The majority of shaders are related to sampling images.

        // These need to be generated with various source textures

        for (auto texture : {srcTexture, externalTexture, f16ExternalTexture}) {

            drawImageLayers(renderengine, display, dstTexture, texture);

            // Draw layers for b/185569240.

            // Draw layers for b/185569240.

        drawClippedLayers(renderengine, display, dstTexture, externalTexture);

            drawClippedLayers(renderengine, display, dstTexture, texture);

        }





        const nsecs_t timeAfter = systemTime();

        const nsecs_t timeAfter = systemTime();

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

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