Support allowSRGBInputs on Vulkan (via secondary texture views)

src/gpu/vk/GrVkTexture.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 "GrVkTexture.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrTexturePriv.h"
 #include "GrVkUtil.h"
 
 #include "vk/GrVkTypes.h"
 
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          SkBudgeted budgeted,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
     , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped) 
-    , fTextureView(view) {
+    , fTextureView(view)
+    , fLinearTextureView(nullptr) {
     this->registerWithCache(budgeted);
 }
 
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          Wrapped,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
     , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
-    , fTextureView(view) {
+    , fTextureView(view)
+    , fLinearTextureView(nullptr) {
     this->registerWithCacheWrapped();
 }
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
     , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
-    , fTextureView(view) {}
+    , fTextureView(view)
+    , fLinearTextureView(nullptr) {}
 
 
 template<typename ResourceType>
 GrVkTexture* GrVkTexture::Create(GrVkGpu* gpu,
                                  ResourceType type,
                                  const GrSurfaceDesc& desc,
                                  VkFormat format,
                                  const GrVkImage::Resource* imageResource) {
     VkImage image = imageResource->fImage;
 
@@ skipping 57 matching lines @@
     }
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return texture;
 }
 
 GrVkTexture::~GrVkTexture() {
     // either release or abandon should have been called by the owner of this object.
     SkASSERT(!fTextureView);
+    SkASSERT(!fLinearTextureView);
 }
 
 void GrVkTexture::onRelease() {
     // we create this and don't hand it off, so we should always destroy it
     if (fTextureView) {
         fTextureView->unref(this->getVkGpu());
         fTextureView = nullptr;
     }
 
+    if (fLinearTextureView) {
+        fLinearTextureView->unref(this->getVkGpu());
+        fLinearTextureView = nullptr;
+    }
+
     this->releaseImage(this->getVkGpu());
 
     INHERITED::onRelease();
 }
 
 void GrVkTexture::onAbandon() {
     if (fTextureView) {
         fTextureView->unrefAndAbandon();
         fTextureView = nullptr;
     }
 
+    if (fLinearTextureView) {
+        fLinearTextureView->unrefAndAbandon();
+        fLinearTextureView = nullptr;
+    }
+
     this->abandonImage();
     INHERITED::onAbandon();
 }
 
 GrBackendObject GrVkTexture::getTextureHandle() const {
     // Currently just passing back the pointer to the Resource as the handle
     return (GrBackendObject)&fResource;
 }
 
 GrVkGpu* GrVkTexture::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }
 
+const GrVkImageView* GrVkTexture::textureView(bool allowSRGB) {
+    VkFormat linearFormat;
+    if (allowSRGB || !GrVkFormatIsSRGB(fResource->fFormat, &linearFormat)) {
+        return fTextureView;
+    }
+
+    if (!fLinearTextureView) {
+        fLinearTextureView = GrVkImageView::Create(this->getVkGpu(), fResource->fImage,
+                                                   linearFormat, GrVkImageView::kColor_Type,
+                                                   fResource->fLevelCount);
+        SkASSERT(fLinearTextureView);
+    }
+
+    return fLinearTextureView;
+}
+
 bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
     if (mipLevels == 1) {
         // don't need to do anything for a 1x1 texture
         return false;
     }
 
     const GrVkImage::Resource* oldResource = fResource;
 
     // We shouldn't realloc something that doesn't belong to us
     if (GrVkImage::Resource::kBorrowed_Flag & oldResource->fFlags) {
@@ skipping 30 matching lines @@
     VkImage image = imageResource->fImage;
     const GrVkImageView* textureView = GrVkImageView::Create(gpu, image, imageResource->fFormat,
                                                              GrVkImageView::kColor_Type, mipLevels);
     if (!textureView) {
         imageResource->unref(gpu);
         return false;
     }
 
     oldResource->unref(gpu);
     oldView->unref(gpu);
+    if (fLinearTextureView) {
+        fLinearTextureView->unref(gpu);
+        fLinearTextureView = nullptr;
+    }
     fResource = imageResource;
     fTextureView = textureView;
     fCurrentLayout = VK_IMAGE_LAYOUT_UNDEFINED;
     this->texturePriv().setMaxMipMapLevel(mipLevels);
 
     return true;
 }