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

Commit fd22d67b authored by android-build-team Robot's avatar android-build-team Robot
Browse files

Snap for 6793271 from 0e0c5f63 to rvc-qpr1-release 

Change-Id: I1457239f7dc8c8d1d8ad898135d9a4f491bc3e16
parents e9cc9005 0e0c5f63

libs/binder/include/binder/AppOpsManager.h

+5 −1
Original line number Diff line number Diff line
@@ -131,7 +131,11 @@ public: 
        OP_DEPRECATED_1 = 96,

        OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED = 97,

        OP_AUTO_REVOKE_MANAGED_BY_INSTALLER = 98,

        _NUM_OP = 99

        OP_NO_ISOLATED_STORAGE = 99,

        OP_PHONE_CALL_MICROPHONE = 100,

        OP_PHONE_CALL_CAMERA = 101,

        OP_RECORD_AUDIO_HOTWORD = 102,

        _NUM_OP = 103

    };



    AppOpsManager();

libs/renderengine/gl/GLESRenderEngine.cpp

+57 −1
Original line number Diff line number Diff line
@@ -409,6 +409,23 @@ GLESRenderEngine::GLESRenderEngine(const RenderEngineCreationArgs& args, EGLDisp 
    mImageManager = std::make_unique<ImageManager>(this);

    mImageManager->initThread();

    mDrawingBuffer = createFramebuffer();

    sp<GraphicBuffer> buf =

            new GraphicBuffer(1, 1, PIXEL_FORMAT_RGBA_8888, 1,

                              GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE, "placeholder");



    const status_t err = buf->initCheck();

    if (err != OK) {

        ALOGE("Error allocating placeholder buffer: %d", err);

        return;

    }

    mPlaceholderBuffer = buf.get();

    EGLint attributes[] = {

            EGL_NONE,

    };

    mPlaceholderImage = eglCreateImageKHR(mEGLDisplay, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,

                                          mPlaceholderBuffer, attributes);

    ALOGE_IF(mPlaceholderImage == EGL_NO_IMAGE_KHR, "Failed to create placeholder image: %#x",

             eglGetError());

}



GLESRenderEngine::~GLESRenderEngine() {
@@ -423,6 +440,7 @@ GLESRenderEngine::~GLESRenderEngine() { 
        eglDestroyImageKHR(mEGLDisplay, expired);

        DEBUG_EGL_IMAGE_TRACKER_DESTROY();

    }

    eglDestroyImageKHR(mEGLDisplay, mPlaceholderImage);

    mImageCache.clear();

    eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    eglTerminate(mEGLDisplay);
@@ -589,6 +607,9 @@ void GLESRenderEngine::genTextures(size_t count, uint32_t* names) { 
}



void GLESRenderEngine::deleteTextures(size_t count, uint32_t const* names) {

    for (int i = 0; i < count; ++i) {

        mTextureView.erase(names[i]);

    }

    glDeleteTextures(count, names);

}
@@ -646,6 +667,7 @@ status_t GLESRenderEngine::bindExternalTextureBuffer(uint32_t texName, 
        }



        bindExternalTextureImage(texName, *cachedImage->second);

        mTextureView.insert_or_assign(texName, buffer->getId());

    }



    // Wait for the new buffer to be ready.
@@ -887,7 +909,7 @@ void GLESRenderEngine::unbindFrameBuffer(Framebuffer* /*framebuffer*/) { 
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

}



bool GLESRenderEngine::cleanupPostRender() {

bool GLESRenderEngine::cleanupPostRender(CleanupMode mode) {

    ATRACE_CALL();



    if (mPriorResourcesCleaned ||
@@ -896,6 +918,30 @@ bool GLESRenderEngine::cleanupPostRender() { 
        return false;

    }



    // This is a bit of a band-aid fix for FrameCaptureProcessor, as we should

    // not need to keep memory around if we don't need to do so.

    if (mode == CleanupMode::CLEAN_ALL) {

        // TODO: SurfaceFlinger memory utilization may benefit from resetting

        // texture bindings as well. Assess if it does and there's no performance regression

        // when rebinding the same image data to the same texture, and if so then its mode

        // behavior can be tweaked.

        if (mPlaceholderImage != EGL_NO_IMAGE_KHR) {

            for (auto [textureName, bufferId] : mTextureView) {

                if (bufferId && mPlaceholderImage != EGL_NO_IMAGE_KHR) {

                    glBindTexture(GL_TEXTURE_EXTERNAL_OES, textureName);

                    glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES,

                                                 static_cast<GLeglImageOES>(mPlaceholderImage));

                    mTextureView[textureName] = std::nullopt;

                    checkErrors();

                }

            }

        }

        {

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

            mImageCache.clear();

        }

    }



    // Bind the texture to dummy data so that backing image data can be freed.

    GLFramebuffer* glFramebuffer = static_cast<GLFramebuffer*>(getFramebufferForDrawing());

    glFramebuffer->allocateBuffers(1, 1, mPlaceholderDrawBuffer);
@@ -1616,6 +1662,16 @@ bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) { 
    return cachedImage != mImageCache.end();

}



bool GLESRenderEngine::isTextureNameKnownForTesting(uint32_t texName) {

    const auto& entry = mTextureView.find(texName);

    return entry != mTextureView.end();

}



std::optional<uint64_t> GLESRenderEngine::getBufferIdForTextureNameForTesting(uint32_t texName) {

    const auto& entry = mTextureView.find(texName);

    return entry != mTextureView.end() ? entry->second : std::nullopt;

}



bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) {

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

    return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(),

libs/renderengine/gl/GLESRenderEngine.h

+14 −1
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ public: 
                        const std::vector<const LayerSettings*>& layers,

                        ANativeWindowBuffer* buffer, const bool useFramebufferCache,

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

    bool cleanupPostRender() override;

    bool cleanupPostRender(CleanupMode mode) override;



    EGLDisplay getEGLDisplay() const { return mEGLDisplay; }

    // Creates an output image for rendering to
@@ -86,6 +86,12 @@ public: 
    // Test-only methods

    // Returns true iff mImageCache contains an image keyed by bufferId

    bool isImageCachedForTesting(uint64_t bufferId) EXCLUDES(mRenderingMutex);

    // Returns true iff texName was previously generated by RenderEngine and was

    // not destroyed.

    bool isTextureNameKnownForTesting(uint32_t texName);

    // Returns the buffer ID of the content bound to texName, or nullopt if no

    // such mapping exists.

    std::optional<uint64_t> getBufferIdForTextureNameForTesting(uint32_t texName);

    // Returns true iff mFramebufferImageCache contains an image keyed by bufferId

    bool isFramebufferImageCachedForTesting(uint64_t bufferId)

            EXCLUDES(mFramebufferImageCacheMutex);
@@ -224,6 +230,8 @@ private: 


    // Cache of GL images that we'll store per GraphicBuffer ID

    std::unordered_map<uint64_t, std::unique_ptr<Image>> mImageCache GUARDED_BY(mRenderingMutex);

    std::unordered_map<uint32_t, std::optional<uint64_t>> mTextureView;



    // Mutex guarding rendering operations, so that:

    // 1. GL operations aren't interleaved, and

    // 2. Internal state related to rendering that is potentially modified by
@@ -237,6 +245,11 @@ private: 
    // ensure that we align on a word. Allocating 16 bytes will provide a

    // guarantee that we don't clobber memory.

    uint32_t mPlaceholderDrawBuffer[4];

    // Placeholder buffer and image, similar to mPlaceholderDrawBuffer, but

    // instead these are intended for cleaning up texture memory with the

    // GL_TEXTURE_EXTERNAL_OES target.

    ANativeWindowBuffer* mPlaceholderBuffer = nullptr;

    EGLImage mPlaceholderImage = EGL_NO_IMAGE_KHR;

    sp<Fence> mLastDrawFence;

    // Store a separate boolean checking if prior resources were cleaned up, as

    // devices that don't support native sync fences can't rely on a last draw

libs/renderengine/include/renderengine/RenderEngine.h

+12 −1
Original line number Diff line number Diff line
@@ -111,14 +111,25 @@ public: 
    // Returns NO_ERROR when binds successfully, NO_MEMORY when there's no memory for allocation.

    virtual status_t bindFrameBuffer(Framebuffer* framebuffer) = 0;

    virtual void unbindFrameBuffer(Framebuffer* framebuffer) = 0;



    enum class CleanupMode {

        CLEAN_OUTPUT_RESOURCES,

        CLEAN_ALL,

    };

    // Clean-up method that should be called on the main thread after the

    // drawFence returned by drawLayers fires. This method will free up

    // resources used by the most recently drawn frame. If the frame is still

    // being drawn, then this call is silently ignored.

    //

    // If mode is CLEAN_OUTPUT_RESOURCES, then only resources related to the

    // output framebuffer are cleaned up, including the sibling texture.

    //

    // If mode is CLEAN_ALL, then we also cleanup resources related to any input

    // buffers.

    //

    // Returns true if resources were cleaned up, and false if we didn't need to

    // do any work.

    virtual bool cleanupPostRender() = 0;

    virtual bool cleanupPostRender(CleanupMode mode = CleanupMode::CLEAN_OUTPUT_RESOURCES) = 0;



    // queries

    virtual size_t getMaxTextureSize() const = 0;

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

+1 −1
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ public: 
    MOCK_CONST_METHOD0(isProtected, bool());

    MOCK_CONST_METHOD0(supportsProtectedContent, bool());

    MOCK_METHOD1(useProtectedContext, bool(bool));

    MOCK_METHOD0(cleanupPostRender, bool());

    MOCK_METHOD1(cleanupPostRender, bool(CleanupMode mode));

    MOCK_METHOD6(drawLayers,

                 status_t(const DisplaySettings&, const std::vector<const LayerSettings*>&,

                          ANativeWindowBuffer*, const bool, base::unique_fd&&, base::unique_fd*));