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

Commit 47814216 authored by Ana Krulec's avatar Ana Krulec
Browse files

Apply the color transform for all shaders 

Test: SurfaceFlinger_test
      --gtest_filter=LayerRenderTypeTransactionTests/LayerRenderTypeTransactionTest.SetColorTransform*
Bug: 175352126
Change-Id: I1c44cdb6b89d0ba7ebe6a4c731298e17f97a9ea1
parent 878166c9

libs/renderengine/skia/SkiaGLRenderEngine.cpp

+36 −29
Original line number Original line Diff line number Diff line
@@ -418,6 +418,32 @@ void SkiaGLRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) { 
    mProtectedTextureCache.erase(bufferId);

    mProtectedTextureCache.erase(bufferId);

}

}





sk_sp<SkShader> SkiaGLRenderEngine::createRuntimeEffectShader(sk_sp<SkShader> shader,

                                                              const LayerSettings* layer,

                                                              const DisplaySettings& display,

                                                              bool undoPremultipliedAlpha) {

    if (mUseColorManagement &&

        needsLinearEffect(layer->colorTransform, layer->sourceDataspace, display.outputDataspace)) {

        LinearEffect effect = LinearEffect{.inputDataspace = layer->sourceDataspace,

                                           .outputDataspace = display.outputDataspace,

                                           .undoPremultipliedAlpha = undoPremultipliedAlpha};



        auto effectIter = mRuntimeEffects.find(effect);

        sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;

        if (effectIter == mRuntimeEffects.end()) {

            runtimeEffect = buildRuntimeEffect(effect);

            mRuntimeEffects.insert({effect, runtimeEffect});

        } else {

            runtimeEffect = effectIter->second;

        }

        return createLinearEffectShader(shader, effect, runtimeEffect, layer->colorTransform,

                                        display.maxLuminance,

                                        layer->source.buffer.maxMasteringLuminance,

                                        layer->source.buffer.maxContentLuminance);

    }

    return shader;

}



status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,

status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display,

                                        const std::vector<const LayerSettings*>& layers,

                                        const std::vector<const LayerSettings*>& layers,

                                        const sp<GraphicBuffer>& buffer,

                                        const sp<GraphicBuffer>& buffer,
@@ -624,41 +650,22 @@ status_t SkiaGLRenderEngine::drawLayers(const DisplaySettings& display, 
                shader = image->makeShader(SkSamplingOptions(), matrix);

                shader = image->makeShader(SkSamplingOptions(), matrix);

            }

            }





            if (mUseColorManagement &&

            paint.setShader(

                needsLinearEffect(layer->colorTransform, layer->sourceDataspace,

                    createRuntimeEffectShader(shader, layer, display,

                                  display.outputDataspace)) {

                                              !item.isOpaque && item.usePremultipliedAlpha));

                LinearEffect effect = LinearEffect{.inputDataspace = layer->sourceDataspace,

                                                   .outputDataspace = display.outputDataspace,

                                                   .undoPremultipliedAlpha = !item.isOpaque &&

                                                           item.usePremultipliedAlpha};



                auto effectIter = mRuntimeEffects.find(effect);

                sk_sp<SkRuntimeEffect> runtimeEffect = nullptr;

                if (effectIter == mRuntimeEffects.end()) {

                    runtimeEffect = buildRuntimeEffect(effect);

                    mRuntimeEffects.insert({effect, runtimeEffect});

                } else {

                    runtimeEffect = effectIter->second;

                }





                paint.setShader(createLinearEffectShader(shader, effect, runtimeEffect,

                                                         layer->colorTransform,

                                                         display.maxLuminance,

                                                         layer->source.buffer.maxMasteringLuminance,

                                                         layer->source.buffer.maxContentLuminance));

            } else {

                paint.setShader(shader);

            }

            // Make sure to take into the account the alpha set on the layer.

            // Make sure to take into the account the alpha set on the layer.

            paint.setAlphaf(layer->alpha);

            paint.setAlphaf(layer->alpha);

        } else {

        } else {

            ATRACE_NAME("DrawColor");

            ATRACE_NAME("DrawColor");

            const auto color = layer->source.solidColor;

            const auto color = layer->source.solidColor;

            paint.setShader(SkShaders::Color(SkColor4f{.fR = color.r,

            sk_sp<SkShader> shader = SkShaders::Color(SkColor4f{.fR = color.r,

                                                                .fG = color.g,

                                                                .fG = color.g,

                                                                .fB = color.b,

                                                                .fB = color.b,

                                                                layer->alpha},

                                                                layer->alpha},

                                             nullptr));

                                                      nullptr);

            paint.setShader(createRuntimeEffectShader(shader, layer, display,

                                                      /* undoPremultipliedAlpha */ false));

        }

        }





        paint.setColorFilter(SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform)));

        paint.setColorFilter(SkColorFilters::Matrix(toSkColorMatrix(display.colorTransform)));

libs/renderengine/skia/SkiaGLRenderEngine.h

+5 −0
Original line number Original line Diff line number Diff line
@@ -91,6 +91,11 @@ private: 
    void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion, const SkRect& layerRect,

    void drawBlurRegion(SkCanvas* canvas, const BlurRegion& blurRegion, const SkRect& layerRect,

                        sk_sp<SkSurface> blurredSurface);

                        sk_sp<SkSurface> blurredSurface);

    SkMatrix getBlurShaderTransform(const SkCanvas* canvas, const SkRect& layerRect);

    SkMatrix getBlurShaderTransform(const SkCanvas* canvas, const SkRect& layerRect);

    // If mUseColorManagement is correct and layer needsLinearEffect, it returns a linear runtime

    // shader. Otherwise it returns the input shader.

    sk_sp<SkShader> createRuntimeEffectShader(sk_sp<SkShader> shader, const LayerSettings* layer,

                                              const DisplaySettings& display,

                                              bool undoPremultipliedAlpha);





    EGLDisplay mEGLDisplay;

    EGLDisplay mEGLDisplay;

    EGLContext mEGLContext;

    EGLContext mEGLContext;