commit 27e1fa257b9c538c53bcfbf30f6fc1833342b055
author Greg Daniel <egdaniel@google.com> Wed May 26 09:24:15 2021 -0400
committer Greg Daniel <egdaniel@google.com> Wed May 26 13:38:33 2021 -0400
tree ae6edc7988ac53b50f696860fe88217811166241
parent 2869d5a8c8def75ed6287cbf8b1514499fd2adc8

In Vk DeferredLayerUpdater make sure we releause buffers to foreign queue.

For Vulkan we need to make sure that when we draw AHBs we must
transition them to and from the foreign queue so that the producer is
able to write new data to them and we are able to see the new writes.

Test: Manual running of Lens app
Bug: 178773035
Change-Id: I807709d2b671bf5a01a82237f3b5838734f0d978

libs/hwui/DeferredLayerUpdater.cpp

diff --git a/libs/hwui/DeferredLayerUpdater.cpp b/libs/hwui/DeferredLayerUpdater.cpp
index 6589dbd..8d112d1 100644
--- a/libs/hwui/DeferredLayerUpdater.cpp
+++ b/libs/hwui/DeferredLayerUpdater.cpp
@@ -76,6 +76,9 @@
 
     mLayer = nullptr;
 
+    for (auto& [index, slot] : mImageSlots) {
+        slot.clear(mRenderState.getRenderThread().getGrContext());
+    }
     mImageSlots.clear();
 }
 
@@ -89,31 +92,39 @@
     }
 }
 
-static status_t createReleaseFence(bool useFenceSync, EGLSyncKHR* eglFence, EGLDisplay* display,
-                                   int* releaseFence, void* handle) {
+status_t DeferredLayerUpdater::createReleaseFence(bool useFenceSync, EGLSyncKHR* eglFence,
+                                                  EGLDisplay* display, int* releaseFence,
+                                                  void* handle) {
     *display = EGL_NO_DISPLAY;
-    RenderState* renderState = (RenderState*)handle;
+    DeferredLayerUpdater* dlu = (DeferredLayerUpdater*)handle;
+    RenderState& renderState = dlu->mRenderState;
     status_t err;
     if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaGL) {
-        EglManager& eglManager = renderState->getRenderThread().eglManager();
+        EglManager& eglManager = renderState.getRenderThread().eglManager();
         *display = eglManager.eglDisplay();
         err = eglManager.createReleaseFence(useFenceSync, eglFence, releaseFence);
     } else {
-        err = renderState->getRenderThread().vulkanManager().createReleaseFence(
-                releaseFence, renderState->getRenderThread().getGrContext());
+        int previousSlot = dlu->mCurrentSlot;
+        if (previousSlot != -1) {
+            dlu->mImageSlots[previousSlot].releaseQueueOwnership(
+                    renderState.getRenderThread().getGrContext());
+        }
+        err = renderState.getRenderThread().vulkanManager().createReleaseFence(
+                releaseFence, renderState.getRenderThread().getGrContext());
     }
     return err;
 }
 
-static status_t fenceWait(int fence, void* handle) {
+status_t DeferredLayerUpdater::fenceWait(int fence, void* handle) {
     // Wait on the producer fence for the buffer to be ready.
     status_t err;
-    RenderState* renderState = (RenderState*)handle;
+    DeferredLayerUpdater* dlu = (DeferredLayerUpdater*)handle;
+    RenderState& renderState = dlu->mRenderState;
     if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaGL) {
-        err = renderState->getRenderThread().eglManager().fenceWait(fence);
+        err = renderState.getRenderThread().eglManager().fenceWait(fence);
     } else {
-        err = renderState->getRenderThread().vulkanManager().fenceWait(
-                fence, renderState->getRenderThread().getGrContext());
+        err = renderState.getRenderThread().vulkanManager().fenceWait(
+                fence, renderState.getRenderThread().getGrContext());
     }
     return err;
 }
@@ -143,9 +154,10 @@
             // cannot tell which mode it is in.
             AHardwareBuffer* hardwareBuffer = ASurfaceTexture_dequeueBuffer(
                     mSurfaceTexture.get(), &slot, &dataspace, transformMatrix, &newContent,
-                    createReleaseFence, fenceWait, &mRenderState);
+                    createReleaseFence, fenceWait, this);
 
             if (hardwareBuffer) {
+                mCurrentSlot = slot;
                 sk_sp<SkImage> layerImage = mImageSlots[slot].createIfNeeded(
                         hardwareBuffer, dataspace, newContent,
                         mRenderState.getRenderThread().getGrContext());
@@ -193,7 +205,7 @@
     if (!mTextureRelease || !mTextureRelease->getImage().get() || dataspace != mDataspace ||
         forceCreate || mBuffer != buffer) {
         if (buffer != mBuffer) {
-            clear();
+            clear(context);
         }
 
         if (!buffer) {
@@ -213,8 +225,11 @@
     return mTextureRelease ? mTextureRelease->getImage() : nullptr;
 }
 
-void DeferredLayerUpdater::ImageSlot::clear() {
+void DeferredLayerUpdater::ImageSlot::clear(GrDirectContext* context) {
     if (mTextureRelease) {
+        if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
+            this->releaseQueueOwnership(context);
+        }
         // The following unref counteracts the initial mUsageCount of 1, set by default initializer.
         mTextureRelease->unref(true);
         mTextureRelease = nullptr;
@@ -223,5 +238,12 @@
     mBuffer = nullptr;
 }
 
+void DeferredLayerUpdater::ImageSlot::releaseQueueOwnership(GrDirectContext* context) {
+    LOG_ALWAYS_FATAL_IF(Properties::getRenderPipelineType() != RenderPipelineType::SkiaVulkan);
+    if (mTextureRelease) {
+        mTextureRelease->releaseQueueOwnership(context);
+    }
+}
+
 } /* namespace uirenderer */
 } /* namespace android */