Refactor Vulkan image, texture, RTs so that create and getter handles match.

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 308 matching lines @@
         VK_IMAGE_ASPECT_COLOR_BIT,
         0,  // mipLevel
         0,  // arraySlice
     };
     VkSubresourceLayout layout;
     VkResult err;
 
     const GrVkInterface* interface = this->vkInterface();
 
     GR_VK_CALL(interface, GetImageSubresourceLayout(fDevice,
-                                                    tex->textureImage(),
+                                                    tex->image(),
                                                     &subres,
                                                     &layout));
 
     int texTop = kBottomLeft_GrSurfaceOrigin == desc.fOrigin ? tex->height() - top - height : top;
     VkDeviceSize offset = texTop*layout.rowPitch + left*bpp;
     VkDeviceSize size = height*layout.rowPitch;
     void* mapPtr;
-    err = GR_VK_CALL(interface, MapMemory(fDevice, tex->textureMemory(), offset, size, 0,
-                                            &mapPtr));
+    err = GR_VK_CALL(interface, MapMemory(fDevice, tex->memory(), offset, size, 0, &mapPtr));
     if (err) {
         return false;
     }
 
     if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
         // copy into buffer by rows
         const char* srcRow = reinterpret_cast<const char*>(data);
         char* dstRow = reinterpret_cast<char*>(mapPtr)+(height - 1)*layout.rowPitch;
         for (int y = 0; y < height; y++) {
             memcpy(dstRow, srcRow, trimRowBytes);
             srcRow += rowBytes;
             dstRow -= layout.rowPitch;
         }
     } else {
         // If there is no padding on the src (rowBytes) or dst (layout.rowPitch) we can memcpy
         if (trimRowBytes == rowBytes && trimRowBytes == layout.rowPitch) {
             memcpy(mapPtr, data, trimRowBytes * height);
         } else {
             SkRectMemcpy(mapPtr, static_cast<size_t>(layout.rowPitch), data, rowBytes,
                             trimRowBytes, height);
         }
     }
 
-    GR_VK_CALL(interface, UnmapMemory(fDevice, tex->textureMemory()));
+    GR_VK_CALL(interface, UnmapMemory(fDevice, tex->memory()));
 
     return true;
 }
 
 bool GrVkGpu::uploadTexDataOptimal(GrVkTexture* tex,
                                     int left, int top, int width, int height,
                                     GrPixelConfig dataConfig,
                                     const SkTArray<GrMipLevel>& texels) {
     SkASSERT(!tex->isLinearTiled());
     // The assumption is either that we have no mipmaps, or that our rect is the entire texture
@@ skipping 228 matching lines @@
     // By default, all textures in Vk use TopLeft
     if (kDefault_GrSurfaceOrigin == origin) {
         return kTopLeft_GrSurfaceOrigin;
     } else {
         return origin;
     }
 }
 
 GrTexture* GrVkGpu::onWrapBackendTexture(const GrBackendTextureDesc& desc,
                                          GrWrapOwnership ownership) {
-    VkFormat format;
-    if (!GrPixelConfigToVkFormat(desc.fConfig, &format)) {
-        return nullptr;
-    }
-
     if (0 == desc.fTextureHandle) {
         return nullptr;
     }
 
     int maxSize = this->caps()->maxTextureSize();
     if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
         return nullptr;
     }
 
-    const GrVkTextureInfo* info = reinterpret_cast<const GrVkTextureInfo*>(desc.fTextureHandle);
+    const GrVkImageInfo* info = reinterpret_cast<const GrVkImageInfo*>(desc.fTextureHandle);
     if (VK_NULL_HANDLE == info->fImage || VK_NULL_HANDLE == info->fAlloc) {
         return nullptr;
     }
+#ifdef SK_DEBUG
+    VkFormat format;
+    if (!GrPixelConfigToVkFormat(desc.fConfig, &format)) {
+        return nullptr;
+    }
+    SkASSERT(format == info->fFormat);
+#endif
 
     GrSurfaceDesc surfDesc;
     // next line relies on GrBackendTextureDesc's flags matching GrTexture's
     surfDesc.fFlags = (GrSurfaceFlags)desc.fFlags;
     surfDesc.fWidth = desc.fWidth;
     surfDesc.fHeight = desc.fHeight;
     surfDesc.fConfig = desc.fConfig;
     surfDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
     bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag);
     // In GL, Chrome assumes all textures are BottomLeft
     // In VK, we don't have this restriction
     surfDesc.fOrigin = resolve_origin(desc.fOrigin);
 
     GrVkTexture* texture = nullptr;
     if (renderTarget) {
         texture = GrVkTextureRenderTarget::CreateWrappedTextureRenderTarget(this, surfDesc,
-                                                                            ownership, format,
-                                                                            info);
+                                                                            ownership, info);
     } else {
-        texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, ownership, format, info);
+        texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, ownership, info);
     }
     if (!texture) {
         return nullptr;
     }
 
     return texture;
 }
 
 GrRenderTarget* GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc,
                                                    GrWrapOwnership ownership) {
 
-    const GrVkTextureInfo* info =
-        reinterpret_cast<const GrVkTextureInfo*>(wrapDesc.fRenderTargetHandle);
+    const GrVkImageInfo* info =
+        reinterpret_cast<const GrVkImageInfo*>(wrapDesc.fRenderTargetHandle);
     if (VK_NULL_HANDLE == info->fImage ||
         (VK_NULL_HANDLE == info->fAlloc && kAdopt_GrWrapOwnership == ownership)) {
         return nullptr;
     }
 
     GrSurfaceDesc desc;
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
@@ skipping 31 matching lines @@
     if (!caps.configCanBeDstofBlit(tex->config(), false) ||
         !caps.configCanBeSrcofBlit(tex->config(), false)) {
         return;
     }
 
     // change the original image's layout
     tex->setImageLayout(this, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                         VK_ACCESS_TRANSFER_READ_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
 
     // grab handle to the original image resource
-    const GrVkImage::Resource* oldResource = tex->resource();
+    const GrVkResource* oldResource = tex->resource();
     oldResource->ref();
+    VkImage oldImage = tex->image();
 
     // 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
     tex->setImageLayout(this, VK_IMAGE_LAYOUT_GENERAL,
                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, false);
 
     // Blit original image
     int width = tex->width();
     int height = tex->height();
 
     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, 0, 0, 1 };
     blitRegion.dstOffsets[0] = { 0, 0, 0 };
     blitRegion.dstOffsets[1] = { width, height, 0 };
 
     fCurrentCmdBuffer->blitImage(this,
                                  oldResource,
+                                 oldImage,
                                  VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                  tex->resource(),
+                                 tex->image(),
                                  VK_IMAGE_LAYOUT_GENERAL,
                                  1,
                                  &blitRegion,
                                  VK_FILTER_LINEAR);
 
     // setup memory barrier
-    SkASSERT(GrVkFormatToPixelConfig(tex->resource()->fFormat, nullptr));
+    SkASSERT(GrVkFormatToPixelConfig(tex->imageFormat(), nullptr));
     VkImageAspectFlags aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
         NULL,                                            // pNext
         VK_ACCESS_TRANSFER_WRITE_BIT,                    // outputMask
         VK_ACCESS_TRANSFER_READ_BIT,                     // inputMask
         VK_IMAGE_LAYOUT_GENERAL,                         // oldLayout
         VK_IMAGE_LAYOUT_GENERAL,                         // newLayout
         VK_QUEUE_FAMILY_IGNORED,                         // srcQueueFamilyIndex
         VK_QUEUE_FAMILY_IGNORED,                         // dstQueueFamilyIndex
-        tex->resource()->fImage,                         // image
+        tex->image(),                                    // image
         { aspectFlags, 0, 1, 0, 1 }                      // subresourceRange
     };
 
     // Blit the miplevels
     uint32_t mipLevel = 1;
     while (mipLevel < levelCount) {
         int prevWidth = width;
         int prevHeight = height;
         width = SkTMax(1, width / 2);
         height = SkTMax(1, height / 2);
 
         imageMemoryBarrier.subresourceRange.baseMipLevel = mipLevel - 1;
         this->addImageMemoryBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                     false, &imageMemoryBarrier);
 
         blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, mipLevel - 1, 0, 1 };
         blitRegion.srcOffsets[0] = { 0, 0, 0 };
         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, height, 0 };
         fCurrentCmdBuffer->blitImage(this,
-                                     tex->resource(),
-                                     VK_IMAGE_LAYOUT_GENERAL,
-                                     tex->resource(),
-                                     VK_IMAGE_LAYOUT_GENERAL,
+                                     *tex,
+                                     *tex,
                                      1,
                                      &blitRegion,
                                      VK_FILTER_LINEAR);
         ++mipLevel;
     }
 
     oldResource->unref(this);
 }
 
 
@@ skipping 142 matching lines @@
                 SkRectMemcpy(mapPtr, static_cast<size_t>(layout.rowPitch), srcData, rowCopyBytes,
                              rowCopyBytes, h);
             }
             VK_CALL(UnmapMemory(fDevice, alloc));
         } else {
             // TODO: Add support for copying to optimal tiling
             SkASSERT(false);
         }
     }
 
-    GrVkTextureInfo* info = new GrVkTextureInfo;
+    GrVkImageInfo* info = new GrVkImageInfo;
     info->fImage = image;
     info->fAlloc = alloc;
     info->fImageTiling = imageTiling;
     info->fImageLayout = initialLayout;
     info->fFormat = pixelFormat;
     info->fLevelCount = 1;
 
     return (GrBackendObject)info;
 }
 
 bool GrVkGpu::isTestingOnlyBackendTexture(GrBackendObject id) const {
-    const GrVkTextureInfo* backend = reinterpret_cast<const GrVkTextureInfo*>(id);
+    const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
 
     if (backend && backend->fImage && backend->fAlloc) {
         VkMemoryRequirements req;
         memset(&req, 0, sizeof(req));
         GR_VK_CALL(this->vkInterface(), GetImageMemoryRequirements(fDevice,
                                                                    backend->fImage,
                                                                    &req));
         // TODO: find a better check
         // This will probably fail with a different driver
         return (req.size > 0) && (req.size <= 8192 * 8192);
     }
 
     return false;
 }
 
 void GrVkGpu::deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandon) {
-    const GrVkTextureInfo* backend = reinterpret_cast<const GrVkTextureInfo*>(id);
+    const GrVkImageInfo* backend = reinterpret_cast<const GrVkImageInfo*>(id);
 
     if (backend) {
         if (!abandon) {
             // something in the command buffer may still be using this, so force submit
             this->submitCommandBuffer(kForce_SyncQueue);
 
             VK_CALL(FreeMemory(this->device(), backend->fAlloc, nullptr));
             VK_CALL(DestroyImage(this->device(), backend->fImage, nullptr));
         }
         delete backend;
@@ skipping 382 matching lines @@
     VkImageBlit blitRegion;
     memset(&blitRegion, 0, sizeof(VkImageBlit));
     blitRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.srcOffsets[0] = { srcVkRect.fLeft, srcVkRect.fTop, 0 };
     blitRegion.srcOffsets[1] = { srcVkRect.fRight, srcVkRect.fBottom, 0 };
     blitRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     blitRegion.dstOffsets[0] = { dstRect.fLeft, dstRect.fTop, 0 };
     blitRegion.dstOffsets[1] = { dstRect.fRight, dstRect.fBottom, 0 };
 
     fCurrentCmdBuffer->blitImage(this,
-                                 srcImage->resource(),
-                                 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                                 dstImage->resource(),
-                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                                 *srcImage,
+                                 *dstImage,
                                  1,
                                  &blitRegion,
                                  VK_FILTER_NEAREST); // We never scale so any filter works here
 
     this->didWriteToSurface(dst, &dstRect);
 }
 
 inline bool can_copy_as_draw(const GrSurface* dst,
                              const GrSurface* src,
                              const GrVkGpu* gpu) {
@@ skipping 290 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
 }