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

Commit da24d274 authored by Noelle Scobie's avatar Noelle Scobie
Browse files

Sync more precompilation updates from upstream Skia 

This includes EdgeExtension, many AnalyticClip updates, etc.

This includes http://review.skia.org/1009516, and speculatively
http://review.skia.org/1009596/14 (approved, unmerged)

Upstream author credit:  Robert Phillips <robertphillips@google.com>

Bug: b/380159947
Bug: b/422805521
Test: comparison of compilation results
Flag: com.android.graphics.surfaceflinger.flags.graphite_renderengine
Change-Id: I6abc7709b2b0e1bf781f4c7f7526d763c23c19d4
parent 71ac6605

libs/renderengine/skia/compat/GraphitePipelineManager.cpp

+130 −58
Original line number Diff line number Diff line
@@ -47,7 +47,10 @@ struct PrecompileSettings { 
    PaintOptions fPaintOptions;

    DrawTypeFlags fDrawTypeFlags = skgpu::graphite::DrawTypeFlags::kNone;

    RenderPassProperties fRenderPassProps;

    bool fAnalyticClipping = false;



    // 'superSet' may have a wider range of DrawTypeFlags.

    // We're intentionally omitting the 'fAnalyticClipping' field here.

    bool isSubsetOf(const PrecompileSettings& superSet) const {

        return (fDrawTypeFlags & superSet.fDrawTypeFlags) &&

                fRenderPassProps == superSet.fRenderPassProps;
@@ -540,6 +543,66 @@ skgpu::graphite::PaintOptions MouriMapCrosstalkAndChunk16x16YCbCr247(RuntimeEffe 
    return paintOptions;

}



skgpu::graphite::PaintOptions EdgeExtensionPremulSrcover(RuntimeEffectManager& effectManager) {

    // This usage of kUnpremul is non-obvious. It acts to short circuit the identity-colorspace

    // optimization for runtime effects. In this case, the Pipeline requires a

    // ColorSpaceTransformPremul instead of the (optimized) Passthrough.

    SkColorInfo ci { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, nullptr };



    sk_sp<PrecompileShader> img = PrecompileShaders::Image(ImageShaderFlags::kExcludeCubic,

                                                           { &ci, 1 },

                                                           {});



    sk_sp<PrecompileShader> edgeEffect = PrecompileRuntimeEffects::MakePrecompileShader(

            effectManager.getKnownRuntimeEffect(RuntimeEffectManager::KnownId::kEdgeExtensionEffect),

            { { std::move(img) } });



    PaintOptions paintOptions;

    paintOptions.setShaders({ std::move(edgeEffect) });

    paintOptions.setBlendModes({ SkBlendMode::kSrcOver });

    return paintOptions;

}



skgpu::graphite::PaintOptions TransparentPaintEdgeExtensionPassthroughSrcover(RuntimeEffectManager& effectManager) {

    SkColorInfo ci { kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr };

    sk_sp<PrecompileShader> img = PrecompileShaders::Image(ImageShaderFlags::kExcludeCubic,

                                                           { &ci, 1 },

                                                           {});



    sk_sp<PrecompileShader> edgeEffect = PrecompileRuntimeEffects::MakePrecompileShader(

            effectManager.getKnownRuntimeEffect(RuntimeEffectManager::KnownId::kEdgeExtensionEffect),

            { { std::move(img) } });



    PaintOptions paintOptions;

    paintOptions.setShaders({ std::move(edgeEffect) });

    paintOptions.setBlendModes({ SkBlendMode::kSrcOver });

    paintOptions.setPaintColorIsOpaque(false);



    return paintOptions;

}



skgpu::graphite::PaintOptions TransparentPaintEdgeExtensionPremulSrcover(RuntimeEffectManager& effectManager) {

    // This usage of kUnpremul is non-obvious. It acts to short circuit the identity-colorspace

    // optimization for runtime effects. In this case, the Pipeline requires a

    // ColorSpaceTransformPremul instead of the (optimized) Passthrough.

    SkColorInfo ci { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, nullptr };



    sk_sp<PrecompileShader> img = PrecompileShaders::Image(ImageShaderFlags::kExcludeCubic,

                                                           { &ci, 1 },

                                                           {});



    sk_sp<PrecompileShader> edgeEffect = PrecompileRuntimeEffects::MakePrecompileShader(

            effectManager.getKnownRuntimeEffect(RuntimeEffectManager::KnownId::kEdgeExtensionEffect),

            { { std::move(img) } });



    PaintOptions paintOptions;

    paintOptions.setShaders({ std::move(edgeEffect) });

    paintOptions.setBlendModes({ SkBlendMode::kSrcOver });

    paintOptions.setPaintColorIsOpaque(false);



    return paintOptions;

}



// clang-format on



// =======================================
@@ -612,6 +675,8 @@ const skgpu::graphite::RenderPassProperties kRGBA16F_1_D_SRGB { 
// NOTE: keep in sync with upstream external/skia/tests/graphite/precompile/PrecompileTestUtils.h

// clang-format off



constexpr bool kWithAnalyticClip = true;



constexpr skgpu::graphite::DrawTypeFlags kRRectAndNonAARect =

        static_cast<skgpu::graphite::DrawTypeFlags>(skgpu::graphite::DrawTypeFlags::kAnalyticRRect |

                                                    skgpu::graphite::DrawTypeFlags::kNonAAFillRect);
@@ -663,19 +728,31 @@ void GraphitePipelineManager::PrecompilePipelines( 
    // clang-format off

    const PrecompileSettings precompileCases[] = {

/*  0 */ { ImagePremulHWOnlySrcover(),         DrawTypeFlags::kNonAAFillRect,   kRGBA16F_1_D },

/*  1 */ { ImagePremulHWOnlySrcover(),         kRRectAndNonAARect,              kRGBA_1_D },

/*  1 */ { ImagePremulHWOnlySrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D,

           kWithAnalyticClip },



/*  2 */ { ImagePremulHWOnlySrcover(),         kRRectAndNonAARect,              kRGBA_4_DS },



/*  3 */ { ImageHWOnlySRGBSrcover(),           DrawTypeFlags::kNonAAFillRect,   kRGBA16F_1_D_SRGB },

/*  4 */ { ImageHWOnlySRGBSrcover(),           kRRectAndNonAARect,              kRGBA_1_D_SRGB },

/*  4 */ { ImageHWOnlySRGBSrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D_SRGB,

           kWithAnalyticClip },



/*  5 */ { TransparentPaintImagePremulHWOnlySrcover(), kRRectAndNonAARect,      kRGBA_1_D },

/*  5 */ { TransparentPaintImagePremulHWOnlySrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D,

           kWithAnalyticClip },

/*  6 */ { TransparentPaintImagePremulHWOnlySrcover(), kRRectAndNonAARect,      kRGBA_4_DS },



/*  7 */ { TransparentPaintImageSRGBHWOnlySrcover(), kRRectAndNonAARect,        kRGBA_1_D_SRGB },



/*  8 */ { SolidSrcSrcover(),                  kRRectAndNonAARect,              kRGBA_1_D },

/*  8 */ { SolidSrcSrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D,

           kWithAnalyticClip },



/*  9 */ { SolidSrcover(),                     kRRectAndNonAARect,              kRGBA_4_DS },
@@ -689,14 +766,20 @@ void GraphitePipelineManager::PrecompilePipelines( 
/* 13 */ { TransparentPaintImagePremulHWOnlyMatrixCFDitherSrcover(),

                                               DrawTypeFlags::kNonAAFillRect,   kRGBA_4_DS },



/* 14 */ { ImagePremulHWOnlyMatrixCFDitherSrcover(), kRRectAndNonAARect,        kRGBA_1_D },

/* 14 */ { ImagePremulHWOnlyMatrixCFDitherSrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D,

           kWithAnalyticClip },



/* 15 */ { ImagePremulHWOnlyMatrixCFDitherSrcover(), DrawTypeFlags::kNonAAFillRect, kRGBA_4_DS },



/* 16 */ { TransparentPaintImageSRGBHWOnlyMatrixCFDitherSrcover(),

                                               kRRectAndNonAARect,              kRGBA_1_D_SRGB },



/* 17 */ { ImageSRGBHWOnlyMatrixCFDitherSrcover(), kRRectAndNonAARect,          kRGBA_1_D_SRGB },

/* 17 */ { ImageSRGBHWOnlyMatrixCFDitherSrcover(),

           kRRectAndNonAARect,

           kRGBA_1_D_SRGB,

           kWithAnalyticClip },



/* 18 */ { ImageSRGBHWOnlyMatrixCFDitherSrcover(), DrawTypeFlags::kAnalyticRRect, kRGBA_4_DS_SRGB },
@@ -706,7 +789,7 @@ void GraphitePipelineManager::PrecompilePipelines( 


/* 21 */ { ImageAlphaSRGBHWOnlyMatrixCFSrcover(), DrawTypeFlags::kNonAAFillRect,kRGBA_1_D_SRGB },



/* 22 */ { ImagePremulHWOnlySrc(),             DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 22 */ { ImagePremulHWOnlySrc(),             kRRectAndNonAARect,              kRGBA_1_D },

/* 23 */ { ImagePremulHWOnlySrc(),             DrawTypeFlags::kPerEdgeAAQuad,   kRGBA_1_D },

/* 24 */ { ImagePremulHWOnlySrc(),             DrawTypeFlags::kNonAAFillRect,   kRGBA_4_DS },
@@ -716,7 +799,7 @@ void GraphitePipelineManager::PrecompilePipelines( 
/* 28 */ { MouriMapChunk8x8Effect(effectManager),           DrawTypeFlags::kNonAAFillRect,   kRGBA16F_1_D },

/* 29 */ { KawaseBlurLowSrcSrcOver(effectManager),          DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 30 */ { KawaseBlurHighSrc(effectManager),                DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 31 */ { BlurFilterMix(effectManager),                    DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 31 */ { BlurFilterMix(effectManager),                    kRRectAndNonAARect,              kRGBA_1_D },



// These two are solid colors drawn w/ a LinearEffect
@@ -795,87 +878,78 @@ void GraphitePipelineManager::PrecompilePipelines( 
// AnalyticClip block - all the PrecompileOptions here are just clones of earlier ones

// with an additional kAnalyticClip flag



// Note: this didn't get folded into #2 since the RRect draw isn't appearing w/ a clip

/* 43 */ { ImagePremulHWOnlySrcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D },



/* 44 */ { ImagePremulHWOnlySrcover(),

           DrawTypeFlags::kNonAAFillRect | DrawTypeFlags::kAnalyticClip,

           kRGBA_4_DS },



/* 45 */ { ImageHWOnlySRGBSrcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D_SRGB },



/* 46 */ { TransparentPaintImagePremulHWOnlySrcover(),

           DrawTypeFlags::kNonAAFillRect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D },



/* 47 */ { SolidSrcSrcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D },



/* 48 */ { SolidSrcSrcover(),

// Note: this didn't get folded into #9 since the RRect draw isn't appearing w/ a clip

/* 44 */ { SolidSrcSrcover(),

           DrawTypeFlags::kNonAAFillRect | DrawTypeFlags::kAnalyticClip,

           kRGBA_4_DS },



/* 49 */ { ImagePremulHWOnlyMatrixCFDitherSrcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D },



/* 50 */ { ImageSRGBHWOnlyMatrixCFDitherSrcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D_SRGB },



//--------------------------------------------------



/* 51 */ { {}, // ignored

/* 45 */ { {}, // ignored

           DrawTypeFlags::kDropShadows,

           kRGBA_1_D },



/* 52 */ { {}, // ignored

/* 46 */ { {}, // ignored

           DrawTypeFlags::kDropShadows,

           kRGBA_4_DS },



// 238 block ----------------

/* 47 */ { EdgeExtensionPremulSrcover(effectManager),

           DrawTypeFlags::kNonAAFillRect,

           kRGBA_1_D },



/* 53 */ { ImagePremulYCbCr238Srcover(),       kRRectAndNonAARect,              kRGBA_1_D },

/* 48 */ { TransparentPaintEdgeExtensionPassthroughSrcover(effectManager),

           DrawTypeFlags::kNonAAFillRect,

           kRGBA_1_D },



/* 54 */ { ImagePremulYCbCr238Srcover(),

           kRRectAndNonAARect | DrawTypeFlags::kAnalyticClip,

/* 49 */ { TransparentPaintEdgeExtensionPremulSrcover(effectManager),

           DrawTypeFlags::kNonAAFillRect,

           kRGBA_1_D },



/* 55 */ { TransparentPaintImagePremulYCbCr238Srcover(), kRRectAndNonAARect,    kRGBA_1_D },

/* 56 */ { ImagePremulYCbCr238Srcover(),       kRRectAndNonAARect,              kRGBA_4_DS },

// 238 block ----------------



/* 50 */ { ImagePremulYCbCr238Srcover(),

           kRRectAndNonAARect,

           kRGBA_1_D,

           kWithAnalyticClip },



/* 51 */ { TransparentPaintImagePremulYCbCr238Srcover(), kRRectAndNonAARect,    kRGBA_1_D },

/* 52 */ { ImagePremulYCbCr238Srcover(),       kRRectAndNonAARect,              kRGBA_4_DS },



/* 57 */ { ImagePremulYCbCr238Srcover(),

// Note: this didn't get folded into #52 since the RRect draw isn't appearing w/ a clip

/* 53 */ { ImagePremulYCbCr238Srcover(),

           DrawTypeFlags::kNonAAFillRect | DrawTypeFlags::kAnalyticClip,

           kRGBA_4_DS },



// 240 block ----------------



/* 58 */ { ImagePremulYCbCr240Srcover(),       DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 59 */ { ImagePremulYCbCr240Srcover(),       DrawTypeFlags::kNonAAFillRect,   kRGBA_4_DS },

/* 50 */ { TransparentPaintImagePremulYCbCr240Srcover(), DrawTypeFlags::kNonAAFillRect,kRGBA_4_DS },

/* 54 */ { ImagePremulYCbCr240Srcover(),       DrawTypeFlags::kNonAAFillRect,   kRGBA_1_D },

/* 55 */ { ImagePremulYCbCr240Srcover(),       DrawTypeFlags::kNonAAFillRect,   kRGBA_4_DS },

/* 56 */ { TransparentPaintImagePremulYCbCr240Srcover(), DrawTypeFlags::kNonAAFillRect,kRGBA_4_DS },



// 247 block ----------------



/* 61 */ { MouriMapCrosstalkAndChunk16x16YCbCr247(effectManager),

/* 57 */ { MouriMapCrosstalkAndChunk16x16YCbCr247(effectManager),

           DrawTypeFlags::kNonAAFillRect,

           kRGBA16F_1_D_SRGB },



// The next 2 have the same PaintOptions but different destination surfaces



/* 62 */ { LinearEffect(kBT2020_ITU_PQ__BT2020__false__UNKNOWN__Shader,

/* 58 */ { LinearEffect(kBT2020_ITU_PQ__BT2020__false__UNKNOWN__Shader,

                        ChildType::kHWTextureYCbCr247,

                        SkBlendMode::kSrcOver,

                        /* paintColorIsOpaque= */ true,

                        /* matrixColorFilter= */ false,

                        /* dither= */ true),

           kRRectAndNonAARect,

           kRGBA_1_D_SRGB },

           kRGBA_1_D_SRGB,

           kWithAnalyticClip },



/* 63 */ { LinearEffect(kBT2020_ITU_PQ__BT2020__false__UNKNOWN__Shader,

/* 59 */ { LinearEffect(kBT2020_ITU_PQ__BT2020__false__UNKNOWN__Shader,

                        ChildType::kHWTextureYCbCr247,

                        SkBlendMode::kSrcOver,

                        /* paintColorIsOpaque= */ true,
@@ -883,15 +957,6 @@ void GraphitePipelineManager::PrecompilePipelines( 
                        /* dither= */ true),

           DrawTypeFlags::kNonAAFillRect,

           kRGBA_4_DS_SRGB },



/* 64 */ { LinearEffect(kBT2020_ITU_PQ__BT2020__false__UNKNOWN__Shader,

                        ChildType::kHWTextureYCbCr247,

                        SkBlendMode::kSrcOver,

                        /* paintColorIsOpaque= */ true,

                        /* matrixColorFilter= */ false,

                        /* dither= */ true),

           DrawTypeFlags::kNonAAFillRect | DrawTypeFlags::kAnalyticClip,

           kRGBA_1_D_SRGB },

    };

    // clang-format on
@@ -901,6 +966,13 @@ void GraphitePipelineManager::PrecompilePipelines( 
        const PrecompileSettings& settings = precompileCases[i];

        Precompile(precompileContext.get(), settings.fPaintOptions, settings.fDrawTypeFlags,

                   {&settings.fRenderPassProps, 1});



        if (settings.fAnalyticClipping) {

            DrawTypeFlags newFlags = settings.fDrawTypeFlags | DrawTypeFlags::kAnalyticClip;



            Precompile(precompileContext.get(), settings.fPaintOptions,

                       static_cast<DrawTypeFlags>(newFlags), {&settings.fRenderPassProps, 1});

        }

    }



    ALOGD("Pipeline precompilation finished");