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

src/gpu/vk/GrVkRenderTarget.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 "GrVkRenderTarget.h"
 
 #include "GrRenderTargetPriv.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkFramebuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkResourceProvider.h"
 #include "GrVkUtil.h"
 
 #include "vk/GrVkTypes.h"
 
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    SkBudgeted budgeted,
                                    const GrSurfaceDesc& desc,
-                                   const GrVkImage::Resource* imageResource,
-                                   const GrVkImage::Resource* msaaResource,
+                                   const GrVkImageInfo& info,
+                                   const GrVkImageInfo& msaaInfo,
                                    const GrVkImageView* colorAttachmentView,
-                                   const GrVkImageView* resolveAttachmentView)
+                                   const GrVkImageView* resolveAttachmentView,
+                                   GrVkImage::Wrapped wrapped)
     : GrSurface(gpu, desc)
-    , GrVkImage(imageResource)
+    , GrVkImage(info, wrapped)
     // for the moment we only support 1:1 color to stencil
     , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
-    , fMSAAImageResource(msaaResource)
+    , fMSAAImage(new GrVkImage(info, GrVkImage::kNot_Wrapped))
     , fResolveAttachmentView(resolveAttachmentView)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(desc.fSampleCnt);
     // The plus 1 is to account for the resolve texture.
     fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
     this->createFramebuffer(gpu);
     this->registerWithCache(budgeted);
-    msaaResource->ref();
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    const GrSurfaceDesc& desc,
-                                   const GrVkImage::Resource* imageResource,
-                                   const GrVkImage::Resource* msaaResource,
+                                   const GrVkImageInfo& info,
+                                   const GrVkImageInfo& msaaInfo,
                                    const GrVkImageView* colorAttachmentView,
-                                   const GrVkImageView* resolveAttachmentView)
+                                   const GrVkImageView* resolveAttachmentView,
+                                   GrVkImage::Wrapped wrapped)
     : GrSurface(gpu, desc)
-    , GrVkImage(imageResource)
+    , GrVkImage(info, wrapped)
     // for the moment we only support 1:1 color to stencil
     , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
-    , fMSAAImageResource(msaaResource)
+    , fMSAAImage(new GrVkImage(info, GrVkImage::kNot_Wrapped))
     , fResolveAttachmentView(resolveAttachmentView)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(desc.fSampleCnt);
     // The plus 1 is to account for the resolve texture.
     fColorValuesPerPixel = desc.fSampleCnt + 1; // TODO: this still correct?
     this->createFramebuffer(gpu);
-    msaaResource->ref();
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    SkBudgeted budgeted,
                                    const GrSurfaceDesc& desc,
-                                   const GrVkImage::Resource* imageResource,
-                                   const GrVkImageView* colorAttachmentView)
+                                   const GrVkImageInfo& info,
+                                   const GrVkImageView* colorAttachmentView,
+                                   GrVkImage::Wrapped wrapped)
     : GrSurface(gpu, desc)
-    , GrVkImage(imageResource)
+    , GrVkImage(info, wrapped)
     , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
-    , fMSAAImageResource(nullptr)
+    , fMSAAImage(nullptr)
     , fResolveAttachmentView(nullptr)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(!desc.fSampleCnt);
     fColorValuesPerPixel = 1;
     this->createFramebuffer(gpu);
     this->registerWithCache(budgeted);
 }
 
 // We're virtually derived from GrSurface (via GrRenderTarget) so its
 // constructor must be explicitly called.
 GrVkRenderTarget::GrVkRenderTarget(GrVkGpu* gpu,
                                    const GrSurfaceDesc& desc,
-                                   const GrVkImage::Resource* imageResource,
-                                   const GrVkImageView* colorAttachmentView)
+                                   const GrVkImageInfo& info,
+                                   const GrVkImageView* colorAttachmentView,
+                                   GrVkImage::Wrapped wrapped)
     : GrSurface(gpu, desc)
-    , GrVkImage(imageResource)
+    , GrVkImage(info, wrapped)
     , GrRenderTarget(gpu, desc, kUnified_SampleConfig)
     , fFramebuffer(nullptr)
     , fColorAttachmentView(colorAttachmentView)
-    , fMSAAImageResource(nullptr)
+    , fMSAAImage(nullptr)
     , fResolveAttachmentView(nullptr)
     , fCachedSimpleRenderPass(nullptr) {
     SkASSERT(!desc.fSampleCnt);
     fColorValuesPerPixel = 1;
     this->createFramebuffer(gpu);
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::Create(GrVkGpu* gpu,
                          SkBudgeted budgeted,
                          const GrSurfaceDesc& desc,
-                         const GrVkImage::Resource* imageResource) {
+                         const GrVkImageInfo& info,
+                         GrVkImage::Wrapped wrapped) {
     VkFormat pixelFormat;
     GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat);
 
     VkImage colorImage;
 
     // create msaa surface if necessary
-    const GrVkImage::Resource* msaaResource = nullptr;
+    GrVkImageInfo msInfo;
     const GrVkImageView* resolveAttachmentView = nullptr;
     if (desc.fSampleCnt) {
         GrVkImage::ImageDesc msImageDesc;
         msImageDesc.fImageType = VK_IMAGE_TYPE_2D;
         msImageDesc.fFormat = pixelFormat;
         msImageDesc.fWidth = desc.fWidth;
         msImageDesc.fHeight = desc.fHeight;
         msImageDesc.fLevels = 1;
         msImageDesc.fSamples = desc.fSampleCnt;
         msImageDesc.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
         msImageDesc.fUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
         msImageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
-        msaaResource = GrVkImage::CreateResource(gpu, msImageDesc);
-
-        if (!msaaResource) {
+        if (!GrVkImage::InitImageInfo(gpu, msImageDesc, &msInfo)) {
             return nullptr;
         }
 
         // Set color attachment image
-        colorImage = msaaResource->fImage;
+        colorImage = msInfo.fImage;
 
         // Create Resolve attachment view
-        resolveAttachmentView = GrVkImageView::Create(gpu, imageResource->fImage, pixelFormat,
+        resolveAttachmentView = GrVkImageView::Create(gpu, info.fImage, pixelFormat,
                                                       GrVkImageView::kColor_Type, 1);
         if (!resolveAttachmentView) {
-            msaaResource->unref(gpu);
+            GrVkImage::DestroyImageInfo(gpu, &msInfo);
             return nullptr;
         }
     } else {
         // Set color attachment image
-        colorImage = imageResource->fImage;
+        colorImage = info.fImage;
     }
 
     // Get color attachment view
     const GrVkImageView* colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat,
                                                                      GrVkImageView::kColor_Type, 1);
     if (!colorAttachmentView) {
-        if (msaaResource) {
+        if (desc.fSampleCnt) {
             resolveAttachmentView->unref(gpu);
-            msaaResource->unref(gpu);
+            GrVkImage::DestroyImageInfo(gpu, &msInfo);
         }
-        return NULL;
+        return nullptr;
     }
 
     GrVkRenderTarget* texRT;
-    if (msaaResource) {
-        texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource, msaaResource,
-                                     colorAttachmentView, resolveAttachmentView);
-        msaaResource->unref(gpu);
+    if (desc.fSampleCnt) {
+        texRT = new GrVkRenderTarget(gpu, budgeted, desc, info, msInfo,
+                                     colorAttachmentView, resolveAttachmentView, wrapped);
     } else {
-        texRT = new GrVkRenderTarget(gpu, budgeted, desc, imageResource,
-                                     colorAttachmentView);
+        texRT = new GrVkRenderTarget(gpu, budgeted, desc, info, colorAttachmentView, wrapped);
     }
 
     return texRT;
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::CreateNewRenderTarget(GrVkGpu* gpu,
                                         SkBudgeted budgeted,
                                         const GrSurfaceDesc& desc,
                                         const GrVkImage::ImageDesc& imageDesc) {
     SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
 
-    const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
-    if (!imageResource) {
+    GrVkImageInfo info;
+    if (!GrVkImage::InitImageInfo(gpu, imageDesc, &info)) {
         return nullptr;
     }
 
-    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, budgeted, desc, imageResource);
-    // Create() will increment the refCount of the image resource if it succeeds
-    imageResource->unref(gpu);
+    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, budgeted, desc, info,
+                                                    GrVkImage::kNot_Wrapped);
+    if (!rt) {
+        GrVkImage::DestroyImageInfo(gpu, &info);
+    }
     return rt;
 }
 
 GrVkRenderTarget*
 GrVkRenderTarget::CreateWrappedRenderTarget(GrVkGpu* gpu,
                                             const GrSurfaceDesc& desc,
                                             GrWrapOwnership ownership,
-                                            const GrVkTextureInfo* info) {
+                                            const GrVkImageInfo* info) {
     SkASSERT(info);
     // We can wrap a rendertarget without its allocation, as long as we don't take ownership
     SkASSERT(VK_NULL_HANDLE != info->fImage);
     SkASSERT(VK_NULL_HANDLE != info->fAlloc || kAdopt_GrWrapOwnership != ownership);
 
-    GrVkImage::Resource::Flags flags = (VK_IMAGE_TILING_LINEAR == info->fImageTiling)
-                                     ? Resource::kLinearTiling_Flag : Resource::kNo_Flags;
+    GrVkImage::Wrapped wrapped = kBorrow_GrWrapOwnership == ownership ? GrVkImage::kBorrowed_Wrapped
+                                                                      : GrVkImage::kAdopted_Wrapped;
 
-    const GrVkImage::Resource* imageResource;
-    if (kBorrow_GrWrapOwnership == ownership) {
-        imageResource = new GrVkImage::BorrowedResource(info->fImage,
-                                                        info->fAlloc,
-                                                        info->fFormat,
-                                                        info->fLevelCount,
-                                                        flags);
-    } else {
-        imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, info->fFormat,
-                                                info->fLevelCount, flags);
-    }
-    if (!imageResource) {
-        return nullptr;
-    }
-
-    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, SkBudgeted::kNo, desc, imageResource);
-    if (rt) {
-        rt->fCurrentLayout = info->fImageLayout;
-    }
-    // Create() will increment the refCount of the image resource if it succeeds
-    imageResource->unref(gpu);
+    GrVkRenderTarget* rt = GrVkRenderTarget::Create(gpu, SkBudgeted::kNo, desc, *info, wrapped);
 
     return rt;
 }
 
 bool GrVkRenderTarget::completeStencilAttachment() {
     this->createFramebuffer(this->getVkGpu());
     return true;
 }
 
 void GrVkRenderTarget::createFramebuffer(GrVkGpu* gpu) {
@@ skipping 41 matching lines @@
         // Currently in vulkan stencil and color attachments must all have same number of samples
         SkASSERT(desc->fColor.fSamples == desc->fStencil.fSamples);
         *attachmentFlags |= GrVkRenderPass::kStencil_AttachmentFlag;
         ++attachmentCount;
     }
     desc->fAttachmentCount = attachmentCount;
 }
 
 GrVkRenderTarget::~GrVkRenderTarget() {
     // either release or abandon should have been called by the owner of this object.
-    SkASSERT(!fMSAAImageResource);
+    SkASSERT(!fMSAAImage);
     SkASSERT(!fResolveAttachmentView);
     SkASSERT(!fColorAttachmentView);
     SkASSERT(!fFramebuffer);
     SkASSERT(!fCachedSimpleRenderPass);
 }
 
 void GrVkRenderTarget::addResources(GrVkCommandBuffer& commandBuffer) const {
     commandBuffer.addResource(this->framebuffer());
     commandBuffer.addResource(this->resource());
     commandBuffer.addResource(this->colorAttachmentView());
     if (this->msaaImageResource()) {
         commandBuffer.addResource(this->msaaImageResource());
         commandBuffer.addResource(this->resolveAttachmentView());
     }
     if (this->stencilImageResource()) {
         commandBuffer.addResource(this->stencilImageResource());
         commandBuffer.addResource(this->stencilAttachmentView());
     }
 }
 
 void GrVkRenderTarget::releaseInternalObjects() {
     GrVkGpu* gpu = this->getVkGpu();
 
-    if (fMSAAImageResource) {
-        fMSAAImageResource->unref(gpu);
-        fMSAAImageResource = nullptr;
+    if (fMSAAImage) {
+        fMSAAImage->releaseImage(gpu);
+        fMSAAImage = nullptr;
     }
 
     if (fResolveAttachmentView) {
         fResolveAttachmentView->unref(gpu);
         fResolveAttachmentView = nullptr;
     }
     if (fColorAttachmentView) {
         fColorAttachmentView->unref(gpu);
         fColorAttachmentView = nullptr;
     }
     if (fFramebuffer) {
         fFramebuffer->unref(gpu);
         fFramebuffer = nullptr;
     }
     if (fCachedSimpleRenderPass) {
         fCachedSimpleRenderPass->unref(gpu);
         fCachedSimpleRenderPass = nullptr;
     }
 }
 
 void GrVkRenderTarget::abandonInternalObjects() {
-    if (fMSAAImageResource) {
-        fMSAAImageResource->unrefAndAbandon();
-        fMSAAImageResource = nullptr;
+    if (fMSAAImage) {
+        fMSAAImage->abandonImage();
+        fMSAAImage = nullptr;
     }
 
     if (fResolveAttachmentView) {
         fResolveAttachmentView->unrefAndAbandon();
         fResolveAttachmentView = nullptr;
     }
     if (fColorAttachmentView) {
         fColorAttachmentView->unrefAndAbandon();
         fColorAttachmentView = nullptr;
     }
@@ skipping 18 matching lines @@
     this->abandonImage();
     GrRenderTarget::onAbandon();
 }
 
 
 GrBackendObject GrVkRenderTarget::getRenderTargetHandle() const {
     // Currently just passing back the pointer to the main Image::Resource as the handle
     return (GrBackendObject)&fResource;
 }
 
-const GrVkImage::Resource* GrVkRenderTarget::stencilImageResource() const {
+const GrVkResource* GrVkRenderTarget::stencilImageResource() const {
     const GrStencilAttachment* stencil = this->renderTargetPriv().getStencilAttachment();
     if (stencil) {
         const GrVkStencilAttachment* vkStencil = static_cast<const GrVkStencilAttachment*>(stencil);
         return vkStencil->imageResource();
     }
 
     return nullptr;
 }
 
 const GrVkImageView* GrVkRenderTarget::stencilAttachmentView() const {
     const GrStencilAttachment* stencil = this->renderTargetPriv().getStencilAttachment();
     if (stencil) {
         const GrVkStencilAttachment* vkStencil = static_cast<const GrVkStencilAttachment*>(stencil);
         return vkStencil->stencilView();
     }
 
     return nullptr;
 }
 
 
 GrVkGpu* GrVkRenderTarget::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }