Check granularity in render pass bounds

src/gpu/vk/GrVkGpu.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 1478 matching lines @@
             SkRectMemcpy(buffer, rowBytes, mappedMemory, tightRowBytes, tightRowBytes, height);
         }
     }
 
     transferBuffer->unmap();
     transferBuffer->unref();
 
     return true;
 }
 
+// The RenderArea bounds we pass into BeginRenderPass must have a start x value that is a multiple
+// of the granularity. The width must also be a multiple of the granularity or eaqual to the width
+// the the entire attachment. Similar requirements for the y and height components.
+void adjust_bounds_to_granularity(SkIRect* dstBounds, const SkIRect& srcBounds,
+                                  const VkExtent2D& granularity, int maxWidth, int maxHeight) {
+    // Adjust Width
+    // Start with the right side of rect so we know if we end up going pass the maxWidth.
+    int rightAdj = srcBounds.fRight % granularity.width;

[jvanverth1, 2016/07/07 18:05:34]

This looks correct. But it seems like it should be a lot like alignment, so
dstRight = (right+granularity.width-1) & ~(granularity.width-1). Elsewhere in
the doc it specifies that image granularity is a power of 2, I'd assume this is
the same.

[egdaniel, 2016/07/07 18:44:59]

I would imagine in practice the granularity (if there even is one) would be a
power of two. But the spec doesn't say this is required as it does for
granularity of other objects. So I'm going to leave this as is until we find out
otherwise.

+    if (rightAdj != 0) {
+        rightAdj = granularity.width - rightAdj;
+    }
+    dstBounds->fRight = srcBounds.fRight + rightAdj;
+    if (dstBounds->fRight > maxWidth) {
+        dstBounds->fRight = maxWidth;
+        dstBounds->fLeft = 0;
+    } else {
+       dstBounds->fLeft = srcBounds.fLeft - srcBounds.fLeft % granularity.width;
+    }
+
+    // Adjust height
+    // Start with the bottom side of rect so we know if we end up going pass the maxHeight.
+    int bottomAdj = srcBounds.fBottom % granularity.height;
+    if (bottomAdj != 0) {
+        bottomAdj = granularity.height - bottomAdj;
+    }
+    dstBounds->fBottom = srcBounds.fBottom + bottomAdj;
+    if (dstBounds->fBottom > maxHeight) {
+        dstBounds->fBottom = maxHeight;
+        dstBounds->fTop = 0;
+    } else {
+       dstBounds->fTop = srcBounds.fTop - srcBounds.fTop % granularity.height;
+    }
+}
+
 void GrVkGpu::submitSecondaryCommandBuffer(GrVkSecondaryCommandBuffer* buffer,
                                            const GrVkRenderPass* renderPass,
                                            const VkClearValue* colorClear,
                                            GrVkRenderTarget* target,
                                            const SkIRect& bounds) {
     const SkIRect* pBounds = &bounds;
     SkIRect flippedBounds;
     if (kBottomLeft_GrSurfaceOrigin == target->origin()) {
         flippedBounds = bounds;
         flippedBounds.fTop = target->height() - bounds.fBottom;
         flippedBounds.fBottom = target->height() - bounds.fTop;
         pBounds = &flippedBounds;
     }
 
+    // The bounds we use for the render pass should be of the granularity supported
+    // by the device.
+    const VkExtent2D& granularity = renderPass->granularity();
+    SkIRect adjustedBounds;
+    if ((0 != granularity.width && 1 != granularity.width) ||
+        (0 != granularity.height && 1 != granularity.height)) {
+        adjust_bounds_to_granularity(&adjustedBounds, *pBounds, granularity,
+                                     target->width(), target->height());
+        pBounds = &adjustedBounds;
+    }
+
     // Currently it is fine for us to always pass in 1 for the clear count even if no attachment
     // uses it. In the current state, we also only use the LOAD_OP_CLEAR for the color attachment
     // which is always at the first attachment.
     fCurrentCmdBuffer->beginRenderPass(this, renderPass, 1, colorClear, *target, *pBounds, true);
     fCurrentCmdBuffer->executeCommands(this, buffer);
     fCurrentCmdBuffer->endRenderPass(this);
 }