1 files changed, 102 insertions, 100 deletions

diff --git a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
index 925db303461f..365d7403e046 100644
--- a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
@@ -16,15 +16,15 @@
 
 #include "SkiaOpenGLPipeline.h"
 
-#include "hwui/Bitmap.h"
 #include "DeferredLayerUpdater.h"
 #include "GlLayer.h"
 #include "LayerDrawable.h"
-#include "renderthread/EglManager.h"
-#include "renderthread/Frame.h"
-#include "renderstate/RenderState.h"
 #include "SkiaPipeline.h"
 #include "SkiaProfileRenderer.h"
+#include "hwui/Bitmap.h"
+#include "renderstate/RenderState.h"
+#include "renderthread/EglManager.h"
+#include "renderthread/Frame.h"
 #include "utils/TraceUtils.h"
 
 #include <GrBackendSurface.h>
@@ -39,9 +39,7 @@ namespace uirenderer {
 namespace skiapipeline {
 
 SkiaOpenGLPipeline::SkiaOpenGLPipeline(RenderThread& thread)
-        : SkiaPipeline(thread)
-        , mEglManager(thread.eglManager()) {
-}
+        : SkiaPipeline(thread), mEglManager(thread.eglManager()) {}
 
 MakeCurrentResult SkiaOpenGLPipeline::makeCurrent() {
     // TODO: Figure out why this workaround is needed, see b/13913604
@@ -55,27 +53,27 @@ MakeCurrentResult SkiaOpenGLPipeline::makeCurrent() {
 
 Frame SkiaOpenGLPipeline::getFrame() {
     LOG_ALWAYS_FATAL_IF(mEglSurface == EGL_NO_SURFACE,
-                "drawRenderNode called on a context with no surface!");
+                        "drawRenderNode called on a context with no surface!");
     return mEglManager.beginFrame(mEglSurface);
 }
 
-bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty,
-        const SkRect& dirty,
-        const FrameBuilder::LightGeometry& lightGeometry,
-        LayerUpdateQueue* layerUpdateQueue,
-        const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
-        const BakedOpRenderer::LightInfo& lightInfo,
-        const std::vector<sp<RenderNode>>& renderNodes,
-        FrameInfoVisualizer* profiler) {
-
+bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
+                              const FrameBuilder::LightGeometry& lightGeometry,
+                              LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
+                              bool opaque, bool wideColorGamut,
+                              const BakedOpRenderer::LightInfo& lightInfo,
+                              const std::vector<sp<RenderNode>>& renderNodes,
+                              FrameInfoVisualizer* profiler) {
     mEglManager.damageFrame(frame, dirty);
 
     // setup surface for fbo0
     GrGLFramebufferInfo fboInfo;
     fboInfo.fFBOID = 0;
+    GrPixelConfig pixelConfig =
+            wideColorGamut ? kRGBA_half_GrPixelConfig : kRGBA_8888_GrPixelConfig;
 
     GrBackendRenderTarget backendRT(frame.width(), frame.height(), 0, STENCIL_BUFFER_SIZE,
-            kRGBA_8888_GrPixelConfig, fboInfo);
+                                    pixelConfig, fboInfo);
 
     SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
 
@@ -84,13 +82,13 @@ bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty,
             mRenderThread.getGrContext(), backendRT, kBottomLeft_GrSurfaceOrigin, nullptr, &props));
 
     SkiaPipeline::updateLighting(lightGeometry, lightInfo);
-    renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, wideColorGamut,
-            contentDrawBounds, surface);
+    renderFrame(*layerUpdateQueue, dirty, renderNodes, opaque, wideColorGamut, contentDrawBounds,
+                surface);
     layerUpdateQueue->clear();
 
     // Draw visual debugging features
-    if (CC_UNLIKELY(Properties::showDirtyRegions
-            || ProfileType::None != Properties::getProfileType())) {
+    if (CC_UNLIKELY(Properties::showDirtyRegions ||
+                    ProfileType::None != Properties::getProfileType())) {
         SkCanvas* profileCanvas = surface->getCanvas();
         SkiaProfileRenderer profileRenderer(profileCanvas);
         profiler->draw(profileRenderer);
@@ -105,9 +103,8 @@ bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty,
     return true;
 }
 
-bool SkiaOpenGLPipeline::swapBuffers(const Frame& frame, bool drew,
-        const SkRect& screenDirty, FrameInfo* currentFrameInfo, bool* requireSwap) {
-
+bool SkiaOpenGLPipeline::swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
+                                     FrameInfo* currentFrameInfo, bool* requireSwap) {
     GL_CHECKPOINT(LOW);
 
     // Even if we decided to cancel the frame, from the perspective of jank
@@ -132,15 +129,30 @@ bool SkiaOpenGLPipeline::copyLayerInto(DeferredLayerUpdater* deferredLayer, SkBi
     deferredLayer->updateTexImage();
     deferredLayer->apply();
 
-    SkCanvas canvas(*bitmap);
+    /* This intermediate surface is present to work around a bug in SwiftShader that
+     * prevents us from reading the contents of the layer's texture directly. The
+     * workaround involves first rendering that texture into an intermediate buffer and
+     * then reading from the intermediate buffer into the bitmap.
+     */
+    sk_sp<SkSurface> tmpSurface = SkSurface::MakeRenderTarget(mRenderThread.getGrContext(),
+                                                              SkBudgeted::kYes, bitmap->info());
+
     Layer* layer = deferredLayer->backingLayer();
-    return LayerDrawable::DrawLayer(mRenderThread.getGrContext(), &canvas, layer);
+    if (LayerDrawable::DrawLayer(mRenderThread.getGrContext(), tmpSurface->getCanvas(), layer)) {
+        sk_sp<SkImage> tmpImage = tmpSurface->makeImageSnapshot();
+        if (tmpImage->readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(), 0, 0)) {
+            bitmap->notifyPixelsChanged();
+            return true;
+        }
+    }
+
+    return false;
 }
 
 static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
-        SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend) {
-    GlLayer* layer = new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha,
-            mode, blend);
+                          SkColorFilter* colorFilter, int alpha, SkBlendMode mode, bool blend) {
+    GlLayer* layer =
+            new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend);
     layer->generateTexture();
     return layer;
 }
@@ -157,8 +169,7 @@ void SkiaOpenGLPipeline::onStop() {
 }
 
 bool SkiaOpenGLPipeline::setSurface(Surface* surface, SwapBehavior swapBehavior,
-        ColorMode colorMode) {
-
+                                    ColorMode colorMode) {
     if (mEglSurface != EGL_NO_SURFACE) {
         mEglManager.destroySurface(mEglSurface);
         mEglSurface = EGL_NO_SURFACE;
@@ -204,8 +215,7 @@ void SkiaOpenGLPipeline::invokeFunctor(const RenderThread& thread, Functor* func
 
 class AutoEglFence {
 public:
-    AutoEglFence(EGLDisplay display)
-            : mDisplay(display) {
+    AutoEglFence(EGLDisplay display) : mDisplay(display) {
         fence = eglCreateSyncKHR(mDisplay, EGL_SYNC_FENCE_KHR, NULL);
     }
 
@@ -216,17 +226,17 @@ public:
     }
 
     EGLSyncKHR fence = EGL_NO_SYNC_KHR;
+
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };
 
 class AutoEglImage {
 public:
-    AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer)
-            : mDisplay(display) {
-        EGLint imageAttrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE };
-        image = eglCreateImageKHR(display, EGL_NO_CONTEXT,
-                EGL_NATIVE_BUFFER_ANDROID, clientBuffer, imageAttrs);
+    AutoEglImage(EGLDisplay display, EGLClientBuffer clientBuffer) : mDisplay(display) {
+        EGLint imageAttrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+        image = eglCreateImageKHR(display, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, clientBuffer,
+                                  imageAttrs);
     }
 
     ~AutoEglImage() {
@@ -236,6 +246,7 @@ public:
     }
 
     EGLImageKHR image = EGL_NO_IMAGE_KHR;
+
 private:
     EGLDisplay mDisplay = EGL_NO_DISPLAY;
 };
@@ -247,16 +258,14 @@ public:
         glBindTexture(GL_TEXTURE_2D, mTexture);
     }
 
-    ~AutoSkiaGlTexture() {
-        glDeleteTextures(1, &mTexture);
-    }
+    ~AutoSkiaGlTexture() { glDeleteTextures(1, &mTexture); }
 
 private:
     GLuint mTexture = 0;
 };
 
 sk_sp<Bitmap> SkiaOpenGLPipeline::allocateHardwareBitmap(renderthread::RenderThread& renderThread,
-        SkBitmap& skBitmap) {
+                                                         SkBitmap& skBitmap) {
     renderThread.eglManager().initialize();
 
     sk_sp<GrContext> grContext = sk_ref_sp(renderThread.getGrContext());
@@ -265,73 +274,67 @@ sk_sp<Bitmap> SkiaOpenGLPipeline::allocateHardwareBitmap(renderthread::RenderThr
     GLint format, type;
     bool isSupported = false;
 
-    //TODO: add support for linear blending (when ANDROID_ENABLE_LINEAR_BLENDING is defined)
+    // TODO: add support for linear blending (when ANDROID_ENABLE_LINEAR_BLENDING is defined)
     switch (info.colorType()) {
-    case kRGBA_8888_SkColorType:
-        isSupported = true;
-    // ARGB_4444 is upconverted to RGBA_8888
-    case kARGB_4444_SkColorType:
-        pixelFormat = PIXEL_FORMAT_RGBA_8888;
-        format = GL_RGBA;
-        type = GL_UNSIGNED_BYTE;
-        break;
-    case kRGBA_F16_SkColorType:
-        isSupported = grContext->caps()->isConfigTexturable(kRGBA_half_GrPixelConfig);
-        if (isSupported) {
-            type = GL_HALF_FLOAT;
-            pixelFormat = PIXEL_FORMAT_RGBA_FP16;
-        } else {
+        case kRGBA_8888_SkColorType:
+            isSupported = true;
+        // ARGB_4444 is upconverted to RGBA_8888
+        case kARGB_4444_SkColorType:
+            pixelFormat = PIXEL_FORMAT_RGBA_8888;
+            format = GL_RGBA;
             type = GL_UNSIGNED_BYTE;
+            break;
+        case kRGBA_F16_SkColorType:
+            isSupported = grContext->caps()->isConfigTexturable(kRGBA_half_GrPixelConfig);
+            if (isSupported) {
+                type = GL_HALF_FLOAT;
+                pixelFormat = PIXEL_FORMAT_RGBA_FP16;
+            } else {
+                type = GL_UNSIGNED_BYTE;
+                pixelFormat = PIXEL_FORMAT_RGBA_8888;
+            }
+            format = GL_RGBA;
+            break;
+        case kRGB_565_SkColorType:
+            isSupported = true;
+            pixelFormat = PIXEL_FORMAT_RGB_565;
+            format = GL_RGB;
+            type = GL_UNSIGNED_SHORT_5_6_5;
+            break;
+        case kGray_8_SkColorType:
+            isSupported = true;
             pixelFormat = PIXEL_FORMAT_RGBA_8888;
-        }
-        format = GL_RGBA;
-        break;
-    case kRGB_565_SkColorType:
-        isSupported = true;
-        pixelFormat = PIXEL_FORMAT_RGB_565;
-        format = GL_RGB;
-        type = GL_UNSIGNED_SHORT_5_6_5;
-        break;
-    case kGray_8_SkColorType:
-        isSupported = true;
-        pixelFormat = PIXEL_FORMAT_RGBA_8888;
-        format = GL_LUMINANCE;
-        type = GL_UNSIGNED_BYTE;
-        break;
-    default:
-        ALOGW("unable to create hardware bitmap of colortype: %d", info.colorType());
-        return nullptr;
-    }
-
-    auto colorSpace = info.colorSpace();
-    bool convertToSRGB = false;
-    if (colorSpace && (!colorSpace->isSRGB())) {
-        isSupported = false;
-        convertToSRGB = true;
+            format = GL_LUMINANCE;
+            type = GL_UNSIGNED_BYTE;
+            break;
+        default:
+            ALOGW("unable to create hardware bitmap of colortype: %d", info.colorType());
+            return nullptr;
     }
 
     SkBitmap bitmap;
     if (isSupported) {
         bitmap = skBitmap;
     } else {
-        bitmap.allocPixels(SkImageInfo::MakeN32(info.width(), info.height(), info.alphaType(),
-                nullptr));
+        bitmap.allocPixels(
+                SkImageInfo::MakeN32(info.width(), info.height(), info.alphaType(), nullptr));
         bitmap.eraseColor(0);
-        if (info.colorType() == kRGBA_F16_SkColorType || convertToSRGB) {
+        if (info.colorType() == kRGBA_F16_SkColorType) {
             // Drawing RGBA_F16 onto ARGB_8888 is not supported
             skBitmap.readPixels(bitmap.info().makeColorSpace(SkColorSpace::MakeSRGB()),
-                    bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
+                                bitmap.getPixels(), bitmap.rowBytes(), 0, 0);
         } else {
             SkCanvas canvas(bitmap);
             canvas.drawBitmap(skBitmap, 0.0f, 0.0f, nullptr);
         }
     }
 
-    sp<GraphicBuffer> buffer = new GraphicBuffer(info.width(), info.height(), pixelFormat,
-            GraphicBuffer::USAGE_HW_TEXTURE |
-            GraphicBuffer::USAGE_SW_WRITE_NEVER |
-            GraphicBuffer::USAGE_SW_READ_NEVER,
-            std::string("Bitmap::allocateSkiaHardwareBitmap pid [") + std::to_string(getpid()) + "]");
+    sp<GraphicBuffer> buffer = new GraphicBuffer(
+            info.width(), info.height(), pixelFormat,
+            GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::USAGE_SW_WRITE_NEVER |
+                    GraphicBuffer::USAGE_SW_READ_NEVER,
+            std::string("Bitmap::allocateSkiaHardwareBitmap pid [") + std::to_string(getpid()) +
+                    "]");
 
     status_t error = buffer->initCheck();
     if (error < 0) {
@@ -339,18 +342,17 @@ sk_sp<Bitmap> SkiaOpenGLPipeline::allocateHardwareBitmap(renderthread::RenderThr
         return nullptr;
     }
 
-    //upload the bitmap into a texture
+    // upload the bitmap into a texture
     EGLDisplay display = eglGetCurrentDisplay();
-    LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY,
-                "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
-                uirenderer::renderthread::EglManager::eglErrorString());
+    LOG_ALWAYS_FATAL_IF(display == EGL_NO_DISPLAY, "Failed to get EGL_DEFAULT_DISPLAY! err=%s",
+                        uirenderer::renderthread::EglManager::eglErrorString());
     // We use an EGLImage to access the content of the GraphicBuffer
     // The EGL image is later bound to a 2D texture
-    EGLClientBuffer clientBuffer = (EGLClientBuffer) buffer->getNativeBuffer();
+    EGLClientBuffer clientBuffer = (EGLClientBuffer)buffer->getNativeBuffer();
     AutoEglImage autoImage(display, clientBuffer);
     if (autoImage.image == EGL_NO_IMAGE_KHR) {
         ALOGW("Could not create EGL image, err =%s",
-                uirenderer::renderthread::EglManager::eglErrorString());
+              uirenderer::renderthread::EglManager::eglErrorString());
         return nullptr;
     }
     AutoSkiaGlTexture glTexture;
@@ -361,7 +363,7 @@ sk_sp<Bitmap> SkiaOpenGLPipeline::allocateHardwareBitmap(renderthread::RenderThr
     // But asynchronous in sense that driver may upload texture onto hardware buffer when we first
     // use it in drawing
     glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, info.width(), info.height(), format, type,
-            bitmap.getPixels());
+                    bitmap.getPixels());
     GL_CHECKPOINT(MODERATE);
 
     // The fence is used to wait for the texture upload to finish
@@ -375,7 +377,7 @@ sk_sp<Bitmap> SkiaOpenGLPipeline::allocateHardwareBitmap(renderthread::RenderThr
     // The flag EGL_SYNC_FLUSH_COMMANDS_BIT_KHR will trigger a
     // pipeline flush (similar to what a glFlush() would do.)
     EGLint waitStatus = eglClientWaitSyncKHR(display, autoFence.fence,
-            EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
+                                             EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, FENCE_TIMEOUT);
     if (waitStatus != EGL_CONDITION_SATISFIED_KHR) {
         LOG_ALWAYS_FATAL("Failed to wait for the fence %#x", eglGetError());
         return nullptr;