Support render-ahead in vulkan

Bug: 127822449
Test: verified render_ahead working with skiavk
Change-Id: Iae1b227a763f6def035057f38cca4b0ab65c7e82
diff --git a/libs/hwui/renderthread/VulkanSurface.cpp b/libs/hwui/renderthread/VulkanSurface.cpp
index 36f540c..447512e 100644
--- a/libs/hwui/renderthread/VulkanSurface.cpp
+++ b/libs/hwui/renderthread/VulkanSurface.cpp
@@ -16,12 +16,12 @@
 
 #include "VulkanSurface.h"
 
-#include <algorithm>
 #include <SkSurface.h>
+#include <algorithm>
 
 #include "VulkanManager.h"
-#include "utils/TraceUtils.h"
 #include "utils/Color.h"
+#include "utils/TraceUtils.h"
 
 namespace android {
 namespace uirenderer {
@@ -31,10 +31,9 @@
     // For now, only support pure rotations, not flip or flip-and-rotate, until we have
     // more time to test them and build sample code. As far as I know we never actually
     // use anything besides pure rotations anyway.
-    return transform == 0
-        || transform == NATIVE_WINDOW_TRANSFORM_ROT_90
-        || transform == NATIVE_WINDOW_TRANSFORM_ROT_180
-        || transform == NATIVE_WINDOW_TRANSFORM_ROT_270;
+    return transform == 0 || transform == NATIVE_WINDOW_TRANSFORM_ROT_90 ||
+           transform == NATIVE_WINDOW_TRANSFORM_ROT_180 ||
+           transform == NATIVE_WINDOW_TRANSFORM_ROT_270;
 }
 
 static int InvertTransform(int transform) {
@@ -85,16 +84,16 @@
 }
 
 void VulkanSurface::ComputeWindowSizeAndTransform(WindowInfo* windowInfo, const SkISize& minSize,
-                                                   const SkISize& maxSize) {
+                                                  const SkISize& maxSize) {
     SkISize& windowSize = windowInfo->size;
 
     // clamp width & height to handle currentExtent of -1 and  protect us from broken hints
-    if (windowSize.width() < minSize.width() || windowSize.width() > maxSize.width()
-        || windowSize.height() < minSize.height() || windowSize.height() > maxSize.height()) {
+    if (windowSize.width() < minSize.width() || windowSize.width() > maxSize.width() ||
+        windowSize.height() < minSize.height() || windowSize.height() > maxSize.height()) {
         int width = std::min(maxSize.width(), std::max(minSize.width(), windowSize.width()));
         int height = std::min(maxSize.height(), std::max(minSize.height(), windowSize.height()));
-        ALOGE("Invalid Window Dimensions [%d, %d]; clamping to [%d, %d]",
-              windowSize.width(), windowSize.height(), width, height);
+        ALOGE("Invalid Window Dimensions [%d, %d]; clamping to [%d, %d]", windowSize.width(),
+              windowSize.height(), width, height);
         windowSize.set(width, height);
     }
 
@@ -145,12 +144,8 @@
 public:
     VkSurfaceAutoDeleter(VkInstance instance, VkSurfaceKHR surface,
                          PFN_vkDestroySurfaceKHR destroySurfaceKHR)
-            : mInstance(instance)
-            , mSurface(surface)
-            , mDestroySurfaceKHR(destroySurfaceKHR) {}
-    ~VkSurfaceAutoDeleter() {
-        destroy();
-    }
+            : mInstance(instance), mSurface(surface), mDestroySurfaceKHR(destroySurfaceKHR) {}
+    ~VkSurfaceAutoDeleter() { destroy(); }
 
     void destroy() {
         if (mSurface != VK_NULL_HANDLE) {
@@ -166,9 +161,9 @@
 };
 
 VulkanSurface* VulkanSurface::Create(ANativeWindow* window, ColorMode colorMode,
-                                       SkColorType colorType, sk_sp<SkColorSpace> colorSpace,
-                                       GrContext* grContext, const VulkanManager& vkManager) {
-
+                                     SkColorType colorType, sk_sp<SkColorSpace> colorSpace,
+                                     GrContext* grContext, const VulkanManager& vkManager,
+                                     uint32_t extraBuffers) {
     VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo;
     memset(&surfaceCreateInfo, 0, sizeof(VkAndroidSurfaceCreateInfoKHR));
     surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
@@ -188,10 +183,11 @@
                                           vkManager.mDestroySurfaceKHR);
 
     SkDEBUGCODE(VkBool32 supported; res = vkManager.mGetPhysicalDeviceSurfaceSupportKHR(
-            vkManager.mPhysicalDevice, vkManager.mPresentQueueIndex, vkSurface, &supported);
-    // All physical devices and queue families on Android must be capable of
-    // presentation with any native window.
-    SkASSERT(VK_SUCCESS == res && supported););
+                                            vkManager.mPhysicalDevice, vkManager.mPresentQueueIndex,
+                                            vkSurface, &supported);
+                // All physical devices and queue families on Android must be capable of
+                // presentation with any native window.
+                SkASSERT(VK_SUCCESS == res && supported););
 
     // check for capabilities
     VkSurfaceCapabilitiesKHR caps;
@@ -225,14 +221,13 @@
     int query_value;
     int err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &query_value);
     if (err != 0 || query_value < 0) {
-        ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
-              query_value);
+        ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err, query_value);
         return nullptr;
     }
     auto min_undequeued_buffers = static_cast<uint32_t>(query_value);
 
-    windowInfo.bufferCount = min_undequeued_buffers
-            + std::max(VulkanSurface::sTargetBufferCount, caps.minImageCount);
+    windowInfo.bufferCount = min_undequeued_buffers +
+                             std::max(sTargetBufferCount + extraBuffers, caps.minImageCount);
     if (caps.maxImageCount > 0 && windowInfo.bufferCount > caps.maxImageCount) {
         // Application must settle for fewer images than desired:
         windowInfo.bufferCount = caps.maxImageCount;
@@ -241,8 +236,7 @@
     // Currently Skia requires the images to be color attachments and support all transfer
     // operations.
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                                   VK_IMAGE_USAGE_SAMPLED_BIT |
-                                   VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+                                   VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     LOG_ALWAYS_FATAL_IF((caps.supportedUsageFlags & usageFlags) != usageFlags);
 
@@ -337,7 +331,8 @@
     err = native_window_set_buffers_data_space(window, windowInfo.dataspace);
     if (err != 0) {
         ALOGE("VulkanSurface::UpdateWindow() native_window_set_buffers_data_space(%d) "
-              "failed: %s (%d)", windowInfo.dataspace, strerror(-err), err);
+              "failed: %s (%d)",
+              windowInfo.dataspace, strerror(-err), err);
         return false;
     }
 
@@ -345,7 +340,8 @@
     err = native_window_set_buffers_dimensions(window, size.width(), size.height());
     if (err != 0) {
         ALOGE("VulkanSurface::UpdateWindow() native_window_set_buffers_dimensions(%d,%d) "
-              "failed: %s (%d)", size.width(), size.height(), strerror(-err), err);
+              "failed: %s (%d)",
+              size.width(), size.height(), strerror(-err), err);
         return false;
     }
 
@@ -358,7 +354,8 @@
     err = native_window_set_buffers_transform(window, InvertTransform(windowInfo.transform));
     if (err != 0) {
         ALOGE("VulkanSurface::UpdateWindow() native_window_set_buffers_transform(%d) "
-              "failed: %s (%d)", windowInfo.transform, strerror(-err), err);
+              "failed: %s (%d)",
+              windowInfo.transform, strerror(-err), err);
         return false;
     }
 
@@ -367,7 +364,8 @@
     err = native_window_set_scaling_mode(window, NATIVE_WINDOW_SCALING_MODE_FREEZE);
     if (err != 0) {
         ALOGE("VulkanSurface::UpdateWindow() native_window_set_scaling_mode(SCALE_TO_WINDOW) "
-              "failed: %s (%d)", strerror(-err), err);
+              "failed: %s (%d)",
+              strerror(-err), err);
         return false;
     }
 
@@ -389,12 +387,12 @@
 }
 
 VulkanSurface::VulkanSurface(ANativeWindow* window, const WindowInfo& windowInfo,
-                               SkISize minWindowSize, SkISize maxWindowSize, GrContext* grContext)
+                             SkISize minWindowSize, SkISize maxWindowSize, GrContext* grContext)
         : mNativeWindow(window)
         , mWindowInfo(windowInfo)
         , mGrContext(grContext)
         , mMinWindowSize(minWindowSize)
-        , mMaxWindowSize(maxWindowSize) { }
+        , mMaxWindowSize(maxWindowSize) {}
 
 VulkanSurface::~VulkanSurface() {
     releaseBuffers();
@@ -437,8 +435,7 @@
     // value at the end of the function if everything dequeued correctly.
     mCurrentBufferInfo = nullptr;
 
-
-    //check if the native window has been resized or rotated and update accordingly
+    // check if the native window has been resized or rotated and update accordingly
     SkISize newSize = SkISize::MakeEmpty();
     int transformHint = 0;
     mNativeWindow->query(mNativeWindow.get(), NATIVE_WINDOW_WIDTH, &newSize.fWidth);
@@ -458,8 +455,8 @@
                                                        newWindowInfo.actualSize.height());
             if (err != 0) {
                 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
-                      newWindowInfo.actualSize.width(),
-                      newWindowInfo.actualSize.height(), strerror(-err), err);
+                      newWindowInfo.actualSize.width(), newWindowInfo.actualSize.height(),
+                      strerror(-err), err);
                 return nullptr;
             }
             // reset the NativeBufferInfo (including SkSurface) associated with the old buffers. The
@@ -470,7 +467,7 @@
 
         if (newWindowInfo.transform != mWindowInfo.transform) {
             err = native_window_set_buffers_transform(mNativeWindow.get(),
-                    InvertTransform(newWindowInfo.transform));
+                                                      InvertTransform(newWindowInfo.transform));
             if (err != 0) {
                 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
                       newWindowInfo.transform, strerror(-err), err);
@@ -513,11 +510,9 @@
     VulkanSurface::NativeBufferInfo* bufferInfo = &mNativeBuffers[idx];
 
     if (bufferInfo->skSurface.get() == nullptr) {
-        bufferInfo->skSurface =
-                SkSurface::MakeFromAHardwareBuffer(mGrContext,
-                        ANativeWindowBuffer_getHardwareBuffer(bufferInfo->buffer.get()),
-                        kTopLeft_GrSurfaceOrigin, DataSpaceToColorSpace(mWindowInfo.dataspace),
-                        nullptr);
+        bufferInfo->skSurface = SkSurface::MakeFromAHardwareBuffer(
+                mGrContext, ANativeWindowBuffer_getHardwareBuffer(bufferInfo->buffer.get()),
+                kTopLeft_GrSurfaceOrigin, DataSpaceToColorSpace(mWindowInfo.dataspace), nullptr);
         if (bufferInfo->skSurface.get() == nullptr) {
             ALOGE("SkSurface::MakeFromAHardwareBuffer failed");
             mNativeWindow->cancelBuffer(mNativeWindow.get(), buffer, fence_fd);