Revert "Revert "Remove GrSurfaceDesc member from GrSurface.""

This reverts commit 4b30a96a3e96b7f051e25025f4f17f3c54e04153.

Bug: skia:
Change-Id: I14d5b402c87df8fffbc29f16686fcfa18474fc48
Reviewed-on: https://skia-review.googlesource.com/17408
Reviewed-by: Greg Daniel <egdaniel@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

diff --git a/include/gpu/GrRenderTarget.h b/include/gpu/GrRenderTarget.h
index fdf6f9cddc6e19e6f40d31697d0f03f4499f4fb7..bd25f4fc0eed06b1e79f53c472372b670a00e308 100644 (file)
--- a/include/gpu/GrRenderTarget.h
+++ b/include/gpu/GrRenderTarget.h
@@ -30,10 +30,10 @@ public:
     const GrRenderTarget* asRenderTarget() const  override { return this; }
 
     // GrRenderTarget
-    bool isStencilBufferMultisampled() const { return fDesc.fSampleCnt > 0; }
+    bool isStencilBufferMultisampled() const { return fSampleCnt > 0; }
 
     GrFSAAType fsaaType() const {
-        if (!fDesc.fSampleCnt) {
+        if (!fSampleCnt) {
             SkASSERT(!(fFlags & Flags::kMixedSampled));
             return GrFSAAType::kNone;
         }
@@ -44,13 +44,13 @@ public:
     /**
      * Returns the number of samples/pixel in the stencil buffer (Zero if non-MSAA).
      */
-    int numStencilSamples() const { return fDesc.fSampleCnt; }
+    int numStencilSamples() const { return fSampleCnt; }
 
     /**
      * Returns the number of samples/pixel in the color buffer (Zero if non-MSAA or mixed sampled).
      */
     int numColorSamples() const {
-        return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fDesc.fSampleCnt;
+        return GrFSAAType::kMixedSamples == this->fsaaType() ? 0 : fSampleCnt;
     }
 
     /**
@@ -135,6 +135,7 @@ private:
     friend class GrRenderTargetPriv;
     friend class GrRenderTargetProxy; // for Flags
 
+    int                   fSampleCnt;
     GrStencilAttachment*  fStencilAttachment;
     uint8_t               fMultisampleSpecsID;
     Flags                 fFlags;

diff --git a/include/gpu/GrSurface.h b/include/gpu/GrSurface.h
index 6626765d6adacdea214c205aed809f98e6a15907..4caa842b4ac9f3785fcfc4e38faba46ecd0ec0f2 100644 (file)
--- a/include/gpu/GrSurface.h
+++ b/include/gpu/GrSurface.h
@@ -23,12 +23,12 @@ public:
     /**
      * Retrieves the width of the surface.
      */
-    int width() const { return fDesc.fWidth; }
+    int width() const { return fWidth; }
 
     /**
      * Retrieves the height of the surface.
      */
-    int height() const { return fDesc.fHeight; }
+    int height() const { return fHeight; }
 
     /**
      * Helper that gets the width and height of the surface as a bounding rectangle.
@@ -36,9 +36,8 @@ public:
     SkRect getBoundsRect() const { return SkRect::MakeIWH(this->width(), this->height()); }
 
     GrSurfaceOrigin origin() const {
-        SkASSERT(kTopLeft_GrSurfaceOrigin == fDesc.fOrigin ||
-                 kBottomLeft_GrSurfaceOrigin == fDesc.fOrigin);
-        return fDesc.fOrigin;
+        SkASSERT(kTopLeft_GrSurfaceOrigin == fOrigin || kBottomLeft_GrSurfaceOrigin == fOrigin);
+        return fOrigin;
     }
 
     /**
@@ -47,7 +46,7 @@ public:
      * if client asked us to render to a target that has a pixel
      * config that isn't equivalent with one of our configs.
      */
-    GrPixelConfig config() const { return fDesc.fConfig; }
+    GrPixelConfig config() const { return fConfig; }
 
     /**
      * @return the texture associated with the surface, may be null.
@@ -79,17 +78,23 @@ protected:
     friend class GrSurfacePriv;
 
     GrSurface(GrGpu* gpu, const GrSurfaceDesc& desc)
-        : INHERITED(gpu)
-        , fDesc(desc) {
-    }
+            : INHERITED(gpu)
+            , fConfig(desc.fConfig)
+            , fWidth(desc.fWidth)
+            , fHeight(desc.fHeight)
+            , fOrigin(desc.fOrigin) {}
     ~GrSurface() override {}
 
-    GrSurfaceDesc fDesc;
 
     void onRelease() override;
     void onAbandon() override;
 
 private:
+    GrPixelConfig        fConfig;
+    int                  fWidth;
+    int                  fHeight;
+    GrSurfaceOrigin      fOrigin;
+
     typedef GrGpuResource INHERITED;
 };
 

diff --git a/include/gpu/GrTexture.h b/include/gpu/GrTexture.h
index 0edcbd0e13fd15958ad91e04a4dfc0d35cf52eb0..a7adc05d0c324881196d45eee8e495ad711d286c 100644 (file)
--- a/include/gpu/GrTexture.h
+++ b/include/gpu/GrTexture.h
@@ -36,7 +36,6 @@ public:
 #ifdef SK_DEBUG
     void validate() const {
         this->INHERITED::validate();
-        this->validateDesc();
     }
 #endif
 
@@ -54,8 +53,6 @@ protected:
     GrTexture(GrGpu*, const GrSurfaceDesc&, GrSLType samplerType,
               GrSamplerParams::FilterMode highestFilterMode, bool wasMipMapDataProvided);
 
-    void validateDesc() const;
-
 private:
     void computeScratchKey(GrScratchKey*) const override;
     size_t onGpuMemorySize() const override;

diff --git a/src/gpu/GrRenderTarget.cpp b/src/gpu/GrRenderTarget.cpp
index 61a6f92f22f8e4c8082f7f5a5f27a6acdda056de..8b1fde6b46e1516beec8f5180d823d0252b26935 100644 (file)
--- a/src/gpu/GrRenderTarget.cpp
+++ b/src/gpu/GrRenderTarget.cpp
@@ -19,11 +19,13 @@
 
 GrRenderTarget::GrRenderTarget(GrGpu* gpu, const GrSurfaceDesc& desc, Flags flags,
                                GrStencilAttachment* stencil)
-    : INHERITED(gpu, desc)
-    , fStencilAttachment(stencil)
-    , fMultisampleSpecsID(0)
-    , fFlags(flags) {
-    SkASSERT(!(fFlags & Flags::kMixedSampled) || fDesc.fSampleCnt > 0);
+        : INHERITED(gpu, desc)
+        , fSampleCnt(desc.fSampleCnt)
+        , fStencilAttachment(stencil)
+        , fMultisampleSpecsID(0)
+        , fFlags(flags) {
+    SkASSERT(desc.fFlags & kRenderTarget_GrSurfaceFlag);
+    SkASSERT(!(fFlags & Flags::kMixedSampled) || fSampleCnt > 0);
     SkASSERT(!(fFlags & Flags::kWindowRectsSupport) || gpu->caps()->maxWindowRectangles() > 0);
     fResolveRect.setLargestInverted();
 }

diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index a46ecb63dd9eab5e578b20a09b58e03981fe31e5..2eb82714a2a60145d073092cd4c29799f2dc5f5c 100644 (file)
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -49,6 +49,28 @@ bool GrResourceProvider::IsFunctionallyExact(GrSurfaceProxy* proxy) {
     return proxy->priv().isExact() || (SkIsPow2(proxy->width()) && SkIsPow2(proxy->height()));
 }
 
+bool validate_desc(const GrSurfaceDesc& desc, const GrCaps& caps, int levelCount = 0) {
+    if (desc.fWidth <= 0 || desc.fHeight <= 0) {
+        return false;
+    }
+    if (!caps.isConfigTexturable(desc.fConfig)) {
+        return false;
+    }
+    if (desc.fFlags & kRenderTarget_GrSurfaceFlag) {
+        if (!caps.isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+            return false;
+        }
+    } else {
+        if (desc.fSampleCnt) {
+            return false;
+        }
+    }
+    if (levelCount > 1 && GrPixelConfigIsSint(desc.fConfig)) {
+        return false;
+    }
+    return true;
+}
+
 // MDB TODO: this should probably be a factory on GrSurfaceProxy
 sk_sp<GrTextureProxy> GrResourceProvider::createMipMappedTexture(
                                                       const GrSurfaceDesc& desc,
@@ -74,11 +96,7 @@ sk_sp<GrTextureProxy> GrResourceProvider::createMipMappedTexture(
         return nullptr;
     }
 
-    if (mipLevelCount > 1 && GrPixelConfigIsSint(desc.fConfig)) {
-        return nullptr;
-    }
-    if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
-        !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+    if (!validate_desc(desc, *fCaps, mipLevelCount)) {
         return nullptr;
     }
 
@@ -133,6 +151,10 @@ sk_sp<GrTextureProxy> GrResourceProvider::createTextureProxy(const GrSurfaceDesc
         return nullptr;
     }
 
+    if (!validate_desc(desc, *fCaps)) {
+        return nullptr;
+    }
+
     GrContext* context = fGpu->getContext();
 
     if (!GrPixelConfigIsCompressed(desc.fConfig)) {
@@ -166,8 +188,7 @@ sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc, Sk
         return nullptr;
     }
 
-    if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
-        !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+    if (!validate_desc(desc, *fCaps)) {
         return nullptr;
     }
 
@@ -195,15 +216,18 @@ GrTexture* GrResourceProvider::createApproxTexture(const GrSurfaceDesc& desc, ui
         return nullptr;
     }
 
+    if (!validate_desc(desc, *fCaps)) {
+        return nullptr;
+    }
+
     return this->refScratchTexture(desc, flags);
 }
 
-GrTexture* GrResourceProvider::refScratchTexture(const GrSurfaceDesc& inDesc,
-                                                 uint32_t flags) {
+GrTexture* GrResourceProvider::refScratchTexture(const GrSurfaceDesc& inDesc, uint32_t flags) {
     ASSERT_SINGLE_OWNER
     SkASSERT(!this->isAbandoned());
     SkASSERT(!GrPixelConfigIsCompressed(inDesc.fConfig));
-    SkASSERT(inDesc.fWidth > 0 && inDesc.fHeight > 0);
+    SkASSERT(validate_desc(inDesc, *fCaps));
 
     SkTCopyOnFirstWrite<GrSurfaceDesc> desc(inDesc);
 

diff --git a/src/gpu/GrTexture.cpp b/src/gpu/GrTexture.cpp
index 0aa1ac07a696271e697ce15da551c82153a54294..cbab5f0f6020ab73b030e84c621cfda2ced2e3bb 100644 (file)
--- a/src/gpu/GrTexture.cpp
+++ b/src/gpu/GrTexture.cpp
@@ -40,18 +40,7 @@ size_t GrTexture::onGpuMemorySize() const {
                                   this->texturePriv().hasMipMaps(), false);
 }
 
-void GrTexture::validateDesc() const {
-    if (this->asRenderTarget()) {
-        // This texture has a render target
-        SkASSERT(0 != (fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
-        SkASSERT(fDesc.fSampleCnt == this->asRenderTarget()->numColorSamples());
-    } else {
-        SkASSERT(0 == (fDesc.fFlags & kRenderTarget_GrSurfaceFlag));
-        SkASSERT(0 == fDesc.fSampleCnt);
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
 
 namespace {
 
@@ -79,7 +68,7 @@ GrTexture::GrTexture(GrGpu* gpu, const GrSurfaceDesc& desc, GrSLType samplerType
     , fMipColorMode(SkDestinationSurfaceColorMode::kLegacy) {
     if (wasMipMapDataProvided) {
         fMipMapsStatus = kValid_MipMapsStatus;
-        fMaxMipMapLevel = SkMipMap::ComputeLevelCount(fDesc.fWidth, fDesc.fHeight);
+        fMaxMipMapLevel = SkMipMap::ComputeLevelCount(this->width(), this->height());
     } else {
         fMipMapsStatus = kNotAllocated_MipMapsStatus;
         fMaxMipMapLevel = 0;
@@ -87,27 +76,42 @@ GrTexture::GrTexture(GrGpu* gpu, const GrSurfaceDesc& desc, GrSLType samplerType
 }
 
 void GrTexture::computeScratchKey(GrScratchKey* key) const {
-    if (!GrPixelConfigIsCompressed(fDesc.fConfig)) {
-        GrTexturePriv::ComputeScratchKey(fDesc, key);
+    if (!GrPixelConfigIsCompressed(this->config())) {
+        const GrRenderTarget* rt = this->asRenderTarget();
+        int sampleCount = 0;
+        if (rt) {
+            sampleCount = rt->numStencilSamples();
+        }
+        GrTexturePriv::ComputeScratchKey(this->config(), this->width(), this->height(),
+                                         this->origin(), SkToBool(rt), sampleCount,
+                                         this->texturePriv().hasMipMaps(), key);
     }
 }
 
-void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
+void GrTexturePriv::ComputeScratchKey(GrPixelConfig config, int width, int height,
+                                      GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
+                                      bool isMipMapped, GrScratchKey* key) {
     static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
+    uint32_t flags = isRenderTarget;
 
-    GrSurfaceOrigin origin = resolve_origin(desc);
-    uint32_t flags = desc.fFlags;
+    SkASSERT(0 == sampleCnt || isRenderTarget);
 
     // make sure desc.fConfig fits in 5 bits
     SkASSERT(sk_float_log2(kLast_GrPixelConfig) <= 5);
-    SkASSERT(static_cast<int>(desc.fConfig) < (1 << 5));
-    SkASSERT(desc.fSampleCnt < (1 << 8));
+    SkASSERT(static_cast<int>(config) < (1 << 5));
+    SkASSERT(sampleCnt < (1 << 8));
     SkASSERT(flags < (1 << 10));
     SkASSERT(static_cast<int>(origin) < (1 << 8));
 
     GrScratchKey::Builder builder(key, kType, 3);
-    builder[0] = desc.fWidth;
-    builder[1] = desc.fHeight;
-    builder[2] = desc.fConfig | (desc.fIsMipMapped << 5) | (desc.fSampleCnt << 6) | (flags << 14)
-                 | (origin << 24);
+    builder[0] = width;
+    builder[1] = height;
+    builder[2] = config | (isMipMapped << 5) | (sampleCnt << 6) | (flags << 14) | (origin << 24);
+}
+
+void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
+    GrSurfaceOrigin origin = resolve_origin(desc);
+    return ComputeScratchKey(desc.fConfig, desc.fWidth, desc.fHeight, origin,
+                             SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag), desc.fSampleCnt,
+                             desc.fIsMipMapped, key);
 }

diff --git a/src/gpu/GrTexturePriv.h b/src/gpu/GrTexturePriv.h
index 042061129d43192b52531bd4fd1d176e8004d37a..67631fc2c4acaab7875e666c257d2e47a75e5bb9 100644 (file)
--- a/src/gpu/GrTexturePriv.h
+++ b/src/gpu/GrTexturePriv.h
@@ -17,18 +17,6 @@
     implemented privately in GrTexture with a inline public method here). */
 class GrTexturePriv {
 public:
-    void setFlag(GrSurfaceFlags flags) {
-        fTexture->fDesc.fFlags = fTexture->fDesc.fFlags | flags;
-    }
-
-    void resetFlag(GrSurfaceFlags flags) {
-        fTexture->fDesc.fFlags = fTexture->fDesc.fFlags & ~flags;
-    }
-
-    bool isSetFlag(GrSurfaceFlags flags) const {
-        return 0 != (fTexture->fDesc.fFlags & flags);
-    }
-
     void dirtyMipMaps(bool mipMapsDirty) {
         fTexture->dirtyMipMaps(mipMapsDirty);
     }
@@ -70,6 +58,10 @@ public:
     static void ComputeScratchKey(const GrSurfaceDesc&, GrScratchKey*);
 
 private:
+    static void ComputeScratchKey(GrPixelConfig config, int width, int height,
+                                  GrSurfaceOrigin origin, bool isRenderTarget, int sampleCnt,
+                                  bool isMipMapped, GrScratchKey* key);
+
     GrTexturePriv(GrTexture* texture) : fTexture(texture) { }
     GrTexturePriv(const GrTexturePriv& that) : fTexture(that.fTexture) { }
     GrTexturePriv& operator=(const GrTexturePriv&); // unimpl

diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index a24a2592a3c643e442d1ad6b23e2b6eca1bfde24..b324280895f70f3973cf963dc35b4d5e68c3cd92 100644 (file)
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -1524,12 +1524,12 @@ GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
         return return_null_texture();
     }
 
-    bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
+    bool isRenderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
 
     GrGLTexture::IDDesc idDesc;
     idDesc.fOwnership = GrBackendObjectOwnership::kOwned;
     GrGLTexture::TexParams initialTexParams;
-    if (!this->createTextureImpl(desc, &idDesc.fInfo, renderTarget, &initialTexParams, texels)) {
+    if (!this->createTextureImpl(desc, &idDesc.fInfo, isRenderTarget, &initialTexParams, texels)) {
         return return_null_texture();
     }
 
@@ -1539,7 +1539,7 @@ GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
     }
 
     GrGLTexture* tex;
-    if (renderTarget) {
+    if (isRenderTarget) {
         // unbind the texture from the texture unit before binding it to the frame buffer
         GL_CALL(BindTexture(idDesc.fInfo.fTarget, 0));
         GrGLRenderTarget::IDDesc rtIDDesc;

diff --git a/src/gpu/gl/GrGLRenderTarget.cpp b/src/gpu/gl/GrGLRenderTarget.cpp
index 7d45ceb619e0d670afa7974ebf039c3ddacc2be2..00a78408d2ab6576fbdffd745c3a133f79ba2be2 100644 (file)
--- a/src/gpu/gl/GrGLRenderTarget.cpp
+++ b/src/gpu/gl/GrGLRenderTarget.cpp
@@ -215,7 +215,7 @@ int GrGLRenderTarget::msaaSamples() const {
     if (fTexFBOID == kUnresolvableFBOID || fTexFBOID != fRTFBOID) {
         // If the render target's FBO is external (fTexFBOID == kUnresolvableFBOID), or if we own
         // the render target's FBO (fTexFBOID == fRTFBOID) then we use the provided sample count.
-        return SkTMax(1, fDesc.fSampleCnt);
+        return SkTMax(1, this->numStencilSamples());
     }
 
     // When fTexFBOID == fRTFBOID, we either are not using MSAA, or MSAA is auto resolving, so use

diff --git a/src/gpu/vk/GrVkTexture.cpp b/src/gpu/vk/GrVkTexture.cpp
index 4857db6f1348c394d7a3b15812ff7cad6b5db62c..826f091ebeefaeb7b31845a81db41ebff9a9d0a0 100644 (file)
--- a/src/gpu/vk/GrVkTexture.cpp
+++ b/src/gpu/vk/GrVkTexture.cpp
@@ -186,7 +186,7 @@ bool GrVkTexture::reallocForMipmap(GrVkGpu* gpu, uint32_t mipLevels) {
         return false;
     }
 
-    bool renderTarget = SkToBool(fDesc.fFlags & kRenderTarget_GrSurfaceFlag);
+    bool renderTarget = SkToBool(this->asRenderTarget());
 
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
     if (renderTarget) {
@@ -197,8 +197,8 @@ bool GrVkTexture::reallocForMipmap(GrVkGpu* gpu, uint32_t mipLevels) {
     GrVkImage::ImageDesc imageDesc;
     imageDesc.fImageType = VK_IMAGE_TYPE_2D;
     imageDesc.fFormat = fInfo.fFormat;
-    imageDesc.fWidth = fDesc.fWidth;
-    imageDesc.fHeight = fDesc.fHeight;
+    imageDesc.fWidth = this->width();
+    imageDesc.fHeight = this->height();
     imageDesc.fLevels = mipLevels;
     imageDesc.fSamples = 1;
     imageDesc.fImageTiling = VK_IMAGE_TILING_OPTIMAL;

diff --git a/src/gpu/vk/GrVkTextureRenderTarget.cpp b/src/gpu/vk/GrVkTextureRenderTarget.cpp
index cfa63be8af40f1c508ef0f2a08d45e8262ac1dc3..2a6810d209a09a172682cf7f20ba2ac5d32dce28 100644 (file)
--- a/src/gpu/vk/GrVkTextureRenderTarget.cpp
+++ b/src/gpu/vk/GrVkTextureRenderTarget.cpp
@@ -152,8 +152,8 @@ GrVkTextureRenderTarget::MakeWrappedTextureRenderTarget(GrVkGpu* gpu,
 
 bool GrVkTextureRenderTarget::updateForMipmap(GrVkGpu* gpu, const GrVkImageInfo& newInfo) {
     VkFormat pixelFormat;
-    GrPixelConfigToVkFormat(fDesc.fConfig, &pixelFormat);
-    if (fDesc.fSampleCnt) {
+    GrPixelConfigToVkFormat(this->config(), &pixelFormat);
+    if (this->numStencilSamples()) {
         const GrVkImageView* resolveAttachmentView =
                 GrVkImageView::Create(gpu,
                                       newInfo.fImage,