Set barriers and image layout changes between mipmap blits.

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 268 matching lines @@
                                       dstAccessMask,
                                       srcStageMask,
                                       dstStageMask,
                                       false);
                 this->submitCommandBuffer(kForce_SyncQueue);
             }
             success = this->uploadTexDataLinear(vkTex, left, top, width, height, config,
                                                 texels.begin()->fPixels, texels.begin()->fRowBytes);
         } else {
             int newMipLevels = texels.count();
-            int currentMipLevels = vkTex->texturePriv().maxMipMapLevel();
-            if ((currentMipLevels || newMipLevels != 1) && newMipLevels != currentMipLevels) {
+            int currentMipLevels = vkTex->texturePriv().maxMipMapLevel() + 1;
+            if (newMipLevels != currentMipLevels) {
                 if (!vkTex->reallocForMipmap(this, newMipLevels)) {
                     return false;
                 }
             }
             success = this->uploadTexDataOptimal(vkTex, left, top, width, height, config, texels);
         }
     }
     
     return success;
 }
@@ skipping 426 matching lines @@
     VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origSrcLayout);
     VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 
     tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                         srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, false);
 
     // grab handle to the original image resource
     const GrVkImage::Resource* oldResource = tex->resource();
     oldResource->ref();
 
-    uint32_t mipLevels = SkMipMap::ComputeLevelCount(tex->width(), tex->height());
-    if (!tex->reallocForMipmap(this, mipLevels)) {
+    // SkMipMap doesn't include the base level in the level count so we have to add 1
+    uint32_t levelCount = SkMipMap::ComputeLevelCount(tex->width(), tex->height()) + 1;
+    if (!tex->reallocForMipmap(this, levelCount)) {
         oldResource->unref(this);
         return;
     }
 
     // change the new image's layout
     VkImageLayout origDstLayout = tex->currentLayout();
 
     srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
     dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 
     srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
     dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 
     tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                         srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, false);
 
     // Blit original image
     int width = tex->width();
     int height = tex->height();
-    uint32_t mipLevel = 0;
 
     VkImageBlit blitRegion;
     memset(&blitRegion, 0, sizeof(VkImageBlit));
     blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.srcOffsets[0] = { 0, 0, 0 };
     blitRegion.srcOffsets[1] = { width, height, 0 };
-    blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 0, 1 };
+    blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.dstOffsets[0] = { 0, 0, 0 };
     blitRegion.dstOffsets[1] = { width, height, 0 };
 
     fCurrentCmdBuffer->blitImage(this,
                                  oldResource,
                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                  tex->resource(),
                                  VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                  1,
                                  &blitRegion,
                                  VK_FILTER_LINEAR);
     // Blit the miplevels
-    while (width/2 > 0 && height/2 > 0) {
-        blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 0, 1 };
+    uint32_t mipLevel = 1;
+    while (mipLevel < levelCount) {
+        int prevWidth = width;
+        int prevHeight = height;
+        width = SkTMax(1, width / 2);
+        height = SkTMax(1, height / 2);
+
+        blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel-1, 0, 1 };
         blitRegion.srcOffsets[0] = { 0, 0, 0 };
-        blitRegion.srcOffsets[1] = { width, height, 0 };
-        blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel+1, 0, 1 };
+        blitRegion.srcOffsets[1] = { prevWidth, prevHeight, 0 };
+        blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel, 0, 1 };
         blitRegion.dstOffsets[0] = { 0, 0, 0 };
-        blitRegion.dstOffsets[1] = { width/2, height/2, 0 };
+        blitRegion.dstOffsets[1] = { width, height, 0 };
 
-        // TODO: insert image barrier to wait on previous blit
-        // TODO: change layout of src subresource to TRANSFER_SRC_OPTIMAL
+        tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                            srcAccessMask, dstAccessMask, srcStageMask, dstStageMask, 
+                            mipLevel-1, 1, false);
 
         fCurrentCmdBuffer->blitImage(this,
                                      tex->resource(),
                                      VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                      tex->resource(),
                                      VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                      1,
                                      &blitRegion,
                                      VK_FILTER_LINEAR);
-
-        width /= 2;
-        height /= 2;
-        mipLevel++;
+        ++mipLevel;
     }
 
     oldResource->unref(this);
 }
 
 
-
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkGpu::bindGeometry(const GrPrimitiveProcessor& primProc,
                            const GrNonInstancedMesh& mesh) {
     // There is no need to put any memory barriers to make sure host writes have finished here.
     // When a command buffer is submitted to a queue, there is an implicit memory barrier that
     // occurs for all host writes. Additionally, BufferMemoryBarriers are not allowed inside of
     // an active RenderPass.
     GrVkVertexBuffer* vbuf;
     vbuf = (GrVkVertexBuffer*)mesh.vertexBuffer();
@@ skipping 986 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }