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

Commit 8002fcab authored by Alec Mouri's avatar Alec Mouri
Browse files

[SurfaceFlinger] Clean-up dead code 

* Remove methods that are no longer used.
* Downgrade visibility of public RenderEngine methods that are currently
unused.

Test: builds
Change-Id: I27d4e1cd7e88b1404d20149e9d0bc89f6cf1bde6
parent 792c6ea9

libs/renderengine/gl/GLESRenderEngine.cpp

+0 −40
Original line number Diff line number Diff line
@@ -456,10 +456,6 @@ void GLESRenderEngine::primeCache() const { 
                                           mFeatureFlags & USE_COLOR_MANAGEMENT);

}



bool GLESRenderEngine::isCurrent() const {

    return mEGLDisplay == eglGetCurrentDisplay() && mEGLContext == eglGetCurrentContext();

}



base::unique_fd GLESRenderEngine::flush() {

    ATRACE_CALL();

    if (!GLExtensions::getInstance().hasNativeFenceSync()) {
@@ -795,7 +791,6 @@ status_t GLESRenderEngine::bindFrameBuffer(Framebuffer* framebuffer) { 
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, 0);



    uint32_t glStatus = glCheckFramebufferStatus(GL_FRAMEBUFFER);



    ALOGE_IF(glStatus != GL_FRAMEBUFFER_COMPLETE_OES, "glCheckFramebufferStatusOES error %d",

             glStatus);
@@ -1013,33 +1008,6 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
    return NO_ERROR;

}



void GLESRenderEngine::setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,

                                                ui::Transform::orientation_flags rotation) {

    setViewportAndProjection(Rect(vpw, vph), sourceCrop);



    if (rotation == ui::Transform::ROT_0) {

        return;

    }



    // Apply custom rotation to the projection.

    float rot90InRadians = 2.0f * static_cast<float>(M_PI) / 4.0f;

    mat4 m = mState.projectionMatrix;

    switch (rotation) {

        case ui::Transform::ROT_90:

            m = mat4::rotate(rot90InRadians, vec3(0, 0, 1)) * m;

            break;

        case ui::Transform::ROT_180:

            m = mat4::rotate(rot90InRadians * 2.0f, vec3(0, 0, 1)) * m;

            break;

        case ui::Transform::ROT_270:

            m = mat4::rotate(rot90InRadians * 3.0f, vec3(0, 0, 1)) * m;

            break;

        default:

            break;

    }

    mState.projectionMatrix = m;

}



void GLESRenderEngine::setViewportAndProjection(Rect viewport, Rect clip) {

    ATRACE_CALL();

    mVpWidth = viewport.getWidth();
@@ -1103,14 +1071,6 @@ void GLESRenderEngine::setupLayerTexturing(const Texture& texture) { 
    mState.textureEnabled = true;

}



void GLESRenderEngine::setupLayerBlackedOut() {

    glBindTexture(GL_TEXTURE_2D, mProtectedTexName);

    Texture texture(Texture::TEXTURE_2D, mProtectedTexName);

    texture.setDimensions(1, 1); // FIXME: we should get that from somewhere

    mState.texture = texture;

    mState.textureEnabled = true;

}



void GLESRenderEngine::setColorTransform(const mat4& colorTransform) {

    mState.colorMatrix = colorTransform;

}

libs/renderengine/gl/GLESRenderEngine.h

+26 −35
Original line number Diff line number Diff line
@@ -50,7 +50,6 @@ class GLESRenderEngine : public impl::RenderEngine { 
public:

    static std::unique_ptr<GLESRenderEngine> create(int hwcFormat, uint32_t featureFlags,

                                                    uint32_t imageCacheSize);

    static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);



    GLESRenderEngine(uint32_t featureFlags, // See RenderEngine::FeatureFlag

                     EGLDisplay display, EGLConfig config, EGLContext ctxt, EGLSurface dummy,
@@ -58,17 +57,7 @@ public: 
                     uint32_t imageCacheSize);

    ~GLESRenderEngine() override EXCLUDES(mRenderingMutex);



    std::unique_ptr<Framebuffer> createFramebuffer() override;

    std::unique_ptr<Image> createImage() override;



    void primeCache() const override;

    bool isCurrent() const override;

    base::unique_fd flush() override;

    bool finish() override;

    bool waitFence(base::unique_fd fenceFd) override;

    void clearWithColor(float red, float green, float blue, float alpha) override;

    void fillRegionWithColor(const Region& region, float red, float green, float blue,

                             float alpha) override;

    void genTextures(size_t count, uint32_t* names) override;

    void deleteTextures(size_t count, uint32_t const* names) override;

    void bindExternalTextureImage(uint32_t texName, const Image& image) override;
@@ -78,7 +67,6 @@ public: 
    void unbindExternalTextureBuffer(uint64_t bufferId) EXCLUDES(mRenderingMutex);

    status_t bindFrameBuffer(Framebuffer* framebuffer) override;

    void unbindFrameBuffer(Framebuffer* framebuffer) override;

    void checkErrors() const override;



    bool isProtected() const override { return mInProtectedContext; }

    bool supportsProtectedContent() const override;
@@ -88,9 +76,7 @@ public: 
                        base::unique_fd&& bufferFence, base::unique_fd* drawFence)

            EXCLUDES(mRenderingMutex) override;



    // internal to RenderEngine

    EGLDisplay getEGLDisplay() const { return mEGLDisplay; }

    EGLConfig getEGLConfig() const { return mEGLConfig; }

    // Creates an output image for rendering to

    EGLImageKHR createFramebufferImageIfNeeded(ANativeWindowBuffer* nativeBuffer, bool isProtected,

                                               bool useFramebufferCache);
@@ -104,27 +90,6 @@ public: 
protected:

    Framebuffer* getFramebufferForDrawing() override;

    void dump(std::string& result) override;

    void setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,

                                  ui::Transform::orientation_flags rotation) override;

    void setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,

                            const half4& color, float cornerRadius) override;

    void setupLayerTexturing(const Texture& texture) override;

    void setupLayerBlackedOut() override;

    void setupFillWithColor(float r, float g, float b, float a) override;

    void setColorTransform(const mat4& colorTransform) override;

    void disableTexturing() override;

    void disableBlending() override;

    void setupCornerRadiusCropSize(float width, float height) override;



    // HDR and color management related functions and state

    void setSourceY410BT2020(bool enable) override;

    void setSourceDataSpace(ui::Dataspace source) override;

    void setOutputDataSpace(ui::Dataspace dataspace) override;

    void setDisplayMaxLuminance(const float maxLuminance) override;



    // drawing

    void drawMesh(const Mesh& mesh) override;



    size_t getMaxTextureSize() const override;

    size_t getMaxViewportDims() const override;
@@ -136,12 +101,16 @@ private: 
        GLES_VERSION_3_0 = 0x30000,

    };



    static EGLConfig chooseEglConfig(EGLDisplay display, int format, bool logConfig);

    static GlesVersion parseGlesVersion(const char* str);

    static EGLContext createEglContext(EGLDisplay display, EGLConfig config,

                                       EGLContext shareContext, bool useContextPriority,

                                       Protection protection);

    static EGLSurface createDummyEglPbufferSurface(EGLDisplay display, EGLConfig config,

                                                   int hwcFormat, Protection protection);

    std::unique_ptr<Framebuffer> createFramebuffer();

    std::unique_ptr<Image> createImage();

    void checkErrors() const;

    void setScissor(const Rect& region);

    void disableScissor();

    bool waitSync(EGLSyncKHR sync, EGLint flags);
@@ -165,6 +134,28 @@ private: 
    // blending is an expensive operation, we want to turn off blending when it's not necessary.

    void handleRoundedCorners(const DisplaySettings& display, const LayerSettings& layer,

                              const Mesh& mesh);

    base::unique_fd flush();

    bool finish();

    bool waitFence(base::unique_fd fenceFd);

    void clearWithColor(float red, float green, float blue, float alpha);

    void fillRegionWithColor(const Region& region, float red, float green, float blue, float alpha);

    void setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,

                            const half4& color, float cornerRadius);

    void setupLayerTexturing(const Texture& texture);

    void setupFillWithColor(float r, float g, float b, float a);

    void setColorTransform(const mat4& colorTransform);

    void disableTexturing();

    void disableBlending();

    void setupCornerRadiusCropSize(float width, float height);



    // HDR and color management related functions and state

    void setSourceY410BT2020(bool enable);

    void setSourceDataSpace(ui::Dataspace source);

    void setOutputDataSpace(ui::Dataspace dataspace);

    void setDisplayMaxLuminance(const float maxLuminance);



    // drawing

    void drawMesh(const Mesh& mesh);



    EGLDisplay mEGLDisplay;

    EGLConfig mEGLConfig;

libs/renderengine/include/renderengine/RenderEngine.h

+0 −56
Original line number Diff line number Diff line
@@ -77,10 +77,6 @@ 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::unique_ptr<Framebuffer> createFramebuffer() = 0;

    virtual std::unique_ptr<Image> createImage() = 0;



    virtual void primeCache() const = 0;



    // dump the extension strings. always call the base class.
@@ -88,24 +84,6 @@ public: 


    virtual bool useNativeFenceSync() const = 0;

    virtual bool useWaitSync() const = 0;



    virtual bool isCurrent() const = 0;



    // helpers

    // flush submits RenderEngine command stream for execution and returns a

    // native fence fd that is signaled when the execution has completed.  It

    // returns -1 on errors.

    virtual base::unique_fd flush() = 0;

    // finish waits until RenderEngine command stream has been executed.  It

    // returns false on errors.

    virtual bool finish() = 0;

    // waitFence inserts a wait on an external fence fd to RenderEngine

    // command stream.  It returns false on errors.

    virtual bool waitFence(base::unique_fd fenceFd) = 0;



    virtual void clearWithColor(float red, float green, float blue, float alpha) = 0;

    virtual void fillRegionWithColor(const Region& region, float red, float green, float blue,

                                     float alpha) = 0;

    virtual void genTextures(size_t count, uint32_t* names) = 0;

    virtual void deleteTextures(size_t count, uint32_t const* names) = 0;

    virtual void bindExternalTextureImage(uint32_t texName, const Image& image) = 0;
@@ -126,40 +104,6 @@ public: 
    virtual status_t bindFrameBuffer(Framebuffer* framebuffer) = 0;

    virtual void unbindFrameBuffer(Framebuffer* framebuffer) = 0;



    // set-up

    virtual void checkErrors() const = 0;

    virtual void setViewportAndProjection(size_t vpw, size_t vph, Rect sourceCrop,

                                          ui::Transform::orientation_flags rotation) = 0;

    virtual void setupLayerBlending(bool premultipliedAlpha, bool opaque, bool disableTexture,

                                    const half4& color, float cornerRadius) = 0;

    virtual void setupLayerTexturing(const Texture& texture) = 0;

    virtual void setupLayerBlackedOut() = 0;

    virtual void setupFillWithColor(float r, float g, float b, float a) = 0;

    // Sets up the crop size for corner radius clipping.

    //

    // Having corner radius will force GPU composition on the layer and its children, drawing it

    // with a special shader. The shader will receive the radius and the crop rectangle as input,

    // modifying the opacity of the destination texture, multiplying it by a number between 0 and 1.

    // We query Layer#getRoundedCornerState() to retrieve the radius as well as the rounded crop

    // rectangle to figure out how to apply the radius for this layer. The crop rectangle will be

    // in local layer coordinate space, so we have to take the layer transform into account when

    // walking up the tree.

    virtual void setupCornerRadiusCropSize(float width, float height) = 0;



    // Set a color transform matrix that is applied in linear space right before OETF.

    virtual void setColorTransform(const mat4& /* colorTransform */) = 0;

    virtual void disableTexturing() = 0;

    virtual void disableBlending() = 0;



    // HDR and color management support

    virtual void setSourceY410BT2020(bool enable) = 0;

    virtual void setSourceDataSpace(ui::Dataspace source) = 0;

    virtual void setOutputDataSpace(ui::Dataspace dataspace) = 0;

    virtual void setDisplayMaxLuminance(const float maxLuminance) = 0;



    // drawing

    virtual void drawMesh(const Mesh& mesh) = 0;



    // queries

    virtual size_t getMaxTextureSize() const = 0;

    virtual size_t getMaxViewportDims() const = 0;

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

+0 −24
Original line number Diff line number Diff line
@@ -34,20 +34,12 @@ public: 
    RenderEngine();

    ~RenderEngine() override;



    MOCK_METHOD0(createFramebuffer, std::unique_ptr<renderengine::Framebuffer>());

    MOCK_METHOD0(createImage, std::unique_ptr<renderengine::Image>());

    MOCK_METHOD0(getFramebufferForDrawing, Framebuffer*());

    MOCK_CONST_METHOD0(primeCache, void());

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

    MOCK_CONST_METHOD0(useNativeFenceSync, bool());

    MOCK_CONST_METHOD0(useWaitSync, bool());

    MOCK_CONST_METHOD0(isCurrent, bool());

    MOCK_METHOD0(flush, base::unique_fd());

    MOCK_METHOD0(finish, bool());

    MOCK_METHOD1(waitFence, bool(base::unique_fd*));

    bool waitFence(base::unique_fd fd) override { return waitFence(&fd); };

    MOCK_METHOD4(clearWithColor, void(float, float, float, float));

    MOCK_METHOD5(fillRegionWithColor, void(const Region&, float, float, float, float));

    MOCK_METHOD2(genTextures, void(size_t, uint32_t*));

    MOCK_METHOD2(deleteTextures, void(size_t, uint32_t const*));

    MOCK_METHOD2(bindExternalTextureImage, void(uint32_t, const renderengine::Image&));
@@ -55,22 +47,6 @@ public: 
    MOCK_METHOD3(bindExternalTextureBuffer,

                 status_t(uint32_t, const sp<GraphicBuffer>&, const sp<Fence>&));

    MOCK_METHOD1(unbindExternalTextureBuffer, void(uint64_t));

    MOCK_CONST_METHOD0(checkErrors, void());

    MOCK_METHOD4(setViewportAndProjection,

                 void(size_t, size_t, Rect, ui::Transform::orientation_flags));

    MOCK_METHOD5(setupLayerBlending, void(bool, bool, bool, const half4&, float));

    MOCK_METHOD1(setupLayerTexturing, void(const Texture&));

    MOCK_METHOD0(setupLayerBlackedOut, void());

    MOCK_METHOD4(setupFillWithColor, void(float, float, float, float));

    MOCK_METHOD2(setupCornerRadiusCropSize, void(float, float));

    MOCK_METHOD1(setColorTransform, void(const mat4&));

    MOCK_METHOD1(setSaturationMatrix, void(const mat4&));

    MOCK_METHOD0(disableTexturing, void());

    MOCK_METHOD0(disableBlending, void());

    MOCK_METHOD1(setSourceY410BT2020, void(bool));

    MOCK_METHOD1(setSourceDataSpace, void(ui::Dataspace));

    MOCK_METHOD1(setOutputDataSpace, void(ui::Dataspace));

    MOCK_METHOD1(setDisplayMaxLuminance, void(const float));

    MOCK_METHOD1(bindFrameBuffer, status_t(renderengine::Framebuffer*));

    MOCK_METHOD1(unbindFrameBuffer, void(renderengine::Framebuffer*));

    MOCK_METHOD1(drawMesh, void(const renderengine::Mesh&));

services/surfaceflinger/BufferLayerConsumer.cpp

+0 −24
Original line number Diff line number Diff line
@@ -419,30 +419,6 @@ std::shared_ptr<FenceTime> BufferLayerConsumer::getCurrentFenceTime() const { 
    return mCurrentFenceTime;

}



status_t BufferLayerConsumer::doFenceWaitLocked() const {

    if (mCurrentFence->isValid()) {

        if (mRE.useWaitSync()) {

            base::unique_fd fenceFd(mCurrentFence->dup());

            if (fenceFd == -1) {

                BLC_LOGE("doFenceWait: error dup'ing fence fd: %d", errno);

                return -errno;

            }

            if (!mRE.waitFence(std::move(fenceFd))) {

                BLC_LOGE("doFenceWait: failed to wait on fence fd");

                return UNKNOWN_ERROR;

            }

        } else {

            status_t err = mCurrentFence->waitForever("BufferLayerConsumer::doFenceWaitLocked");

            if (err != NO_ERROR) {

                BLC_LOGE("doFenceWait: error waiting for fence: %d", err);

                return err;

            }

        }

    }



    return NO_ERROR;

}



void BufferLayerConsumer::freeBufferLocked(int slotIndex) {

    BLC_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);

    std::lock_guard<std::mutex> lock(mImagesMutex);