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

Commit 2daef3c6 authored by Alec Mouri's avatar Alec Mouri
Browse files

Add ExternalTexture class into RenderEngine interface 

ExternalTexture is an RAII structure that wraps raw GraphicBuffers that
are passed into RenderEngine. ExternalTexture's role is to help with
managing GPU resources of GraphicBuffers by mapping buffers into
textures, EGLImages, or AutoBackendTextures depending on the
RenderEngine backend. Under the hood, mapExternalTextureBuffer and
unmapExternalTextureBuffer (renamed from cacheExternalTextureBuffer and
unbindExternalTextureBuffer respectively) are used to help tie
resource management to the ExternalTexture lifetime.

The main motivation for this is that currently managing buffer
lifecycle has historically been errorprone and caused memory leaks, so
this improves code health.

As part of this:
* mapExternalTextureBuffer and unmapExternalTextureBuffer
are now protected methods, and are never called outside of RenderEngine
with the exception of creating and destroying ExternalTextures.
* Because GLESRenderEngine's output buffers are cached differently from
Skia RenderEngine, if there are output-only buffers then disable the
mapExternalTextureBuffer calls whenever GLESRenderEngine is used.
* Custom RAII classes in the Planner and in BufferLayerConsumer are now
removed since they're subsumed by ExternalTexture
* RenderSurface now controls its own management of ExternalTextures in a
small queue
* cleanFramebufferCache is now unimplemented for Skia, because
ExternalTextures are now deleted whenever a RenderSurface is deleted.

Bug: 180767535
Test: libsurfaceflinger_unittest
Test: libcompositionengine_test
Test: librenderengine_test
Test: Simulate virtual displays
Test: Screen reotation
Test: Movie playback on Google TV
Test: Force GPU composition
Test: screenshot

Change-Id: I222c71e6e1c67485cdeac49e2cb829289af9efec
parent f9932d79

libs/renderengine/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ filegroup { 
    name: "librenderengine_sources",

    srcs: [

        "Description.cpp",

        "ExternalTexture.cpp",

        "Mesh.cpp",

        "RenderEngine.cpp",

        "Texture.cpp",

libs/renderengine/ExternalTexture.cpp

0 → 100644
+43 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <renderengine/ExternalTexture.h>

#include <renderengine/RenderEngine.h>

#include <ui/GraphicBuffer.h>



#include "log/log_main.h"



namespace android::renderengine {



ExternalTexture::ExternalTexture(const sp<GraphicBuffer>& buffer, RenderEngine& renderEngine,

                                 uint32_t usage)

      : mBuffer(buffer), mRenderEngine(renderEngine) {

    LOG_ALWAYS_FATAL_IF(buffer == nullptr,

                        "Attempted to bind a null buffer to an external texture!");

    // GLESRenderEngine has a separate texture cache for output buffers,

    if (usage == Usage::WRITEABLE &&

        (mRenderEngine.getRenderEngineType() == RenderEngine::RenderEngineType::GLES ||

         mRenderEngine.getRenderEngineType() == RenderEngine::RenderEngineType::THREADED)) {

        return;

    }

    mRenderEngine.mapExternalTextureBuffer(mBuffer, usage & Usage::WRITEABLE);

}



ExternalTexture::~ExternalTexture() {

    mRenderEngine.unmapExternalTextureBuffer(mBuffer);

}



} // namespace android::renderengine

libs/renderengine/gl/GLESRenderEngine.cpp

+17 −13
Original line number Diff line number Diff line
@@ -746,7 +746,8 @@ void GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, const sp<Grap 
    return;

}



void GLESRenderEngine::cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {

void GLESRenderEngine::mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer,

                                                bool /*isRenderable*/) {

    ATRACE_CALL();

    mImageManager->cacheAsync(buffer, nullptr);

}
@@ -797,8 +798,8 @@ status_t GLESRenderEngine::cacheExternalTextureBufferInternal(const sp<GraphicBu 
    return NO_ERROR;

}



void GLESRenderEngine::unbindExternalTextureBuffer(uint64_t bufferId) {

    mImageManager->releaseAsync(bufferId, nullptr);

void GLESRenderEngine::unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) {

    mImageManager->releaseAsync(buffer->getId(), nullptr);

}



std::shared_ptr<ImageManager::Barrier> GLESRenderEngine::unbindExternalTextureBufferForTesting(
@@ -1102,7 +1103,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer 


status_t GLESRenderEngine::drawLayers(const DisplaySettings& display,

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

                                      const sp<GraphicBuffer>& buffer,

                                      const std::shared_ptr<ExternalTexture>& buffer,

                                      const bool useFramebufferCache, base::unique_fd&& bufferFence,

                                      base::unique_fd* drawFence) {

    ATRACE_CALL();
@@ -1125,7 +1126,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
        return BAD_VALUE;

    }



    validateOutputBufferUsage(buffer);

    validateOutputBufferUsage(buffer->getBuffer());



    std::unique_ptr<BindNativeBufferAsFramebuffer> fbo;

    // Gathering layers that requested blur, we'll need them to decide when to render to an
@@ -1142,11 +1143,13 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 


    if (blurLayersSize == 0) {

        fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this,

                                                              buffer.get()->getNativeBuffer(),

                                                              buffer->getBuffer()

                                                                      .get()

                                                                      ->getNativeBuffer(),

                                                              useFramebufferCache);

        if (fbo->getStatus() != NO_ERROR) {

            ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",

                  buffer->handle);

                  buffer->getBuffer()->handle);

            checkErrors();

            return fbo->getStatus();

        }
@@ -1157,7 +1160,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
                mBlurFilter->setAsDrawTarget(display, blurLayers.front()->backgroundBlurRadius);

        if (status != NO_ERROR) {

            ALOGE("Failed to prepare blur filter! Aborting GPU composition for buffer (%p).",

                  buffer->handle);

                  buffer->getBuffer()->handle);

            checkErrors();

            return status;

        }
@@ -1194,7 +1197,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            auto status = mBlurFilter->prepare();

            if (status != NO_ERROR) {

                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't render first blur pass");

                return status;

            }
@@ -1203,6 +1206,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
                // Done blurring, time to bind the native FBO and render our blur onto it.

                fbo = std::make_unique<BindNativeBufferAsFramebuffer>(*this,

                                                                      buffer.get()

                                                                              ->getBuffer()

                                                                              ->getNativeBuffer(),

                                                                      useFramebufferCache);

                status = fbo->getStatus();
@@ -1215,7 +1219,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            }

            if (status != NO_ERROR) {

                ALOGE("Failed to bind framebuffer! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't bind native framebuffer");

                return status;

            }
@@ -1223,7 +1227,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            status = mBlurFilter->render(blurLayersSize > 1);

            if (status != NO_ERROR) {

                ALOGE("Failed to render blur effect! Aborting GPU composition for buffer (%p).",

                      buffer->handle);

                      buffer->getBuffer()->handle);

                checkErrors("Can't render blur filter");

                return status;

            }
@@ -1250,7 +1254,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 
            disableTexture = false;

            isOpaque = layer->source.buffer.isOpaque;



            sp<GraphicBuffer> gBuf = layer->source.buffer.buffer;

            sp<GraphicBuffer> gBuf = layer->source.buffer.buffer->getBuffer();

            validateInputBufferUsage(gBuf);

            bindExternalTextureBuffer(layer->source.buffer.textureName, gBuf,

                                      layer->source.buffer.fence);
@@ -1274,7 +1278,7 @@ status_t GLESRenderEngine::drawLayers(const DisplaySettings& display, 


            // Do not cache protected EGLImage, protected memory is limited.

            if (gBuf->getUsage() & GRALLOC_USAGE_PROTECTED) {

                unbindExternalTextureBuffer(gBuf->getId());

                unmapExternalTextureBuffer(gBuf);

            }

        }

libs/renderengine/gl/GLESRenderEngine.h

+6 −5
Original line number Diff line number Diff line
@@ -60,16 +60,14 @@ public: 
    void primeCache() override;

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

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

    void cacheExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);

    void unbindExternalTextureBuffer(uint64_t bufferId) EXCLUDES(mRenderingMutex);



    bool isProtected() const override { return mInProtectedContext; }

    bool supportsProtectedContent() const override;

    bool useProtectedContext(bool useProtectedContext) override;

    status_t drawLayers(const DisplaySettings& display,

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

                        const sp<GraphicBuffer>& buffer, const bool useFramebufferCache,

                        base::unique_fd&& bufferFence, base::unique_fd* drawFence) override;

                        const std::shared_ptr<ExternalTexture>& buffer,

                        const bool useFramebufferCache, base::unique_fd&& bufferFence,

                        base::unique_fd* drawFence) override;

    bool cleanupPostRender(CleanupMode mode) override;

    int getContextPriority() override;

    bool supportsBackgroundBlur() override { return mBlurFilter != nullptr; }
@@ -105,6 +103,9 @@ protected: 
            EXCLUDES(mFramebufferImageCacheMutex);

    size_t getMaxTextureSize() const override;

    size_t getMaxViewportDims() const override;

    void mapExternalTextureBuffer(const sp<GraphicBuffer>& buffer, bool isRenderable)

            EXCLUDES(mRenderingMutex);

    void unmapExternalTextureBuffer(const sp<GraphicBuffer>& buffer) EXCLUDES(mRenderingMutex);



private:

    friend class BindNativeBufferAsFramebuffer;

libs/renderengine/include/renderengine/ExternalTexture.h

0 → 100644
+61 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <android-base/macros.h>

#include <ui/GraphicBuffer.h>



namespace android::renderengine {



class RenderEngine;



/**

 * Manages GPU image resources on behalf of clients using RenderEngine.

 *

 * Clients of RenderEngine are required to wrap their GraphicBuffer objects as an ExternalTexture,

 * which is then mapped into GPU resources required by RenderEngine. When a client no longer needs

 * to use the GraphicBuffer as input into RenderEngine::drawLayers, then the client should delete

 * their ExternalTexture so that resources may be freed.

 */

class ExternalTexture {

public:

    // Usage specifies the rendering intent for the buffer.

    enum Usage : uint32_t {

        // When a buffer is not READABLE but is WRITEABLE, then GLESRenderEngine will use that as a

        // hint to load the buffer into a separate cache

        READABLE = 1 << 0,



        // The buffer needs to be mapped as a 2D texture if set, otherwise must be mapped as an

        // external texture

        WRITEABLE = 1 << 1,

    };

    // Creates an ExternalTexture for the provided buffer and RenderEngine instance, with the given

    // usage hint of type Usage.

    ExternalTexture(const sp<GraphicBuffer>& buffer, RenderEngine& renderEngine, uint32_t usage);



    ~ExternalTexture();



    // Retrieves the buffer that is bound to this texture.

    const sp<GraphicBuffer>& getBuffer() const { return mBuffer; }



private:

    sp<GraphicBuffer> mBuffer;

    RenderEngine& mRenderEngine;

    DISALLOW_COPY_AND_ASSIGN(ExternalTexture);

};



} // namespace android::renderengine