Separate out natively-texture image/bmp draws from cached-as-texture image/bmp draws

src/gpu/GrTextureParamsAdjuster.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 "GrTextureParamsAdjuster.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrGpu.h"
 #include "GrGpuResourcePriv.h"
 #include "GrResourceKey.h"
 #include "GrTexture.h"
 #include "GrTextureParams.h"
 #include "GrTextureProvider.h"
 #include "SkCanvas.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
+#include "effects/GrBicubicEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef GrTextureProducer::CopyParams CopyParams;
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GrTexture* copy_on_gpu(GrTexture* inputTexture, const SkIRect* subset,
                               const CopyParams& copyParams) {
     SkASSERT(!subset || !subset->isEmpty());
     GrContext* context = inputTexture->getContext();
@@ skipping 92 matching lines @@
         contentArea.fRight < original->width() || contentArea.fBottom < original->height()) {
         fContentArea.set(contentArea);
     }
 }
 
 GrTexture* GrTextureAdjuster::refTextureSafeForParams(const GrTextureParams& params,
                                                       SkIPoint* outOffset) {
     GrTexture* texture = this->originalTexture();
     GrContext* context = texture->getContext();
     CopyParams copyParams;
-    const SkIRect* contentArea = this->contentArea();
+    const SkIRect* contentArea = this->contentAreaOrNull();
 
     if (contentArea && GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
         // If we generate a MIP chain for texture it will read pixel values from outside the content
         // area.
         copyParams.fWidth = contentArea->width();
         copyParams.fHeight = contentArea->height();
         copyParams.fFilter = GrTextureParams::kBilerp_FilterMode;
     } else if (!context->getGpu()->makeCopyForTextureParams(texture->width(), texture->height(),
                                                             params, &copyParams)) {
         if (outOffset) {
@@ skipping 19 matching lines @@
             result->resourcePriv().setUniqueKey(key);
             this->didCacheCopy(key);
         }
         if (outOffset) {
             outOffset->set(0, 0);
         }
     }
     return result;
 }
 
+enum DomainMode {
+    kNoDomain_DomainMode,
+    kDomain_DomainMode,
+    kTightCopy_DomainMode
+};
+
+/** Determines whether a texture domain is necessary and if so what domain to use. There are two
+ *  rectangles to consider:
+ *  - The first is the content area specified by the texture adjuster. We can *never* allow
+ *    filtering to cause bleed of pixels outside this rectangle.
+ *  - The second rectangle is the constraint rectangle, which is known to be contained by the
+ *    content area. The filterConstraint specifies whether we are allowed to bleed across this
+ *    rect.
+ *
+ *  We want to avoid using a domain if possible. We consider the above rectangles, the filter type,
+ *  and whether the coords generated by the draw would all fall within the constraint rect. If the
+ *  latter is true we only need to consider whether the filter would extend beyond the rects.
+ */
+static DomainMode determine_domain_mode(
+                                    const SkRect& constraintRect,
+                                    GrTextureAdjuster::FilterConstraint filterConstraint,

[robertphillips, 2015/11/06 20:54:51]

...LimitedTo... (i.e., add "To") ?
Contraint -> Constraint ?

[bsalomon, 2015/11/09 19:35:22]

Done.

+                                    bool coordsLimitedContraintRect,
+                                    int texW, int texH,
+                                    const SkIRect* textureContentArea,
+                                    const GrTextureParams::FilterMode* filterModeOrNullForBicubic,
+                                    SkRect* domainRect) {
+
+    SkASSERT(SkRect::MakeIWH(texW, texH).contains(constraintRect));
+    // We only expect a content area rect if there is some non-content area.
+    SkASSERT(!textureContentArea ||
+             (!textureContentArea->contains(SkIRect::MakeWH(texW, texH)) &&
+              SkRect::Make(*textureContentArea).contains(constraintRect)));
+
+    SkRect textureBounds = SkRect::MakeIWH(texW, texH);
+    // If the src rectangle contains the whole texture then no need for a domain.
+    if (constraintRect.contains(textureBounds)) {
+        return kNoDomain_DomainMode;
+    }
+
+    bool restrictFilterToRect = (filterConstraint == GrTextureAdjuster::kYes_FilterConstraint);
+
+    // If we can filter outside the constraint rect, and there is no non-content area of the
+    // texture, and we aren't going to generate sample coords outside the constraint rect then we
+    // don't need a domain.
+    if (!restrictFilterToRect && !textureContentArea && coordsLimitedContraintRect) {
+        return kNoDomain_DomainMode;
+    }
+
+    // Get the domain inset based on sampling mode (or bail if mipped)
+    SkScalar filterHalfWidth;
+    if (filterModeOrNullForBicubic) {
+        switch (*filterModeOrNullForBicubic) {
+            case GrTextureParams::kNone_FilterMode:
+                if (coordsLimitedContraintRect) {
+                    return kNoDomain_DomainMode;
+                } else {
+                    filterHalfWidth = 0.f;
+                }
+                break;
+            case GrTextureParams::kBilerp_FilterMode:

[robertphillips, 2015/11/06 20:54:51]

Wouldn't this be 0.5f for half filter width ? Isn't this more filter margin ?

[bsalomon, 2015/11/09 19:35:22]

It's supposed to really be half-width, fixed the values.

+                filterHalfWidth = 1.f;
+                break;
+            case GrTextureParams::kMipMap_FilterMode:
+                // No domain can save use here.
+                return kTightCopy_DomainMode;
+        }
+    } else {
+        // bicubic does nearest filtering internally.
+        filterHalfWidth = 2.f;
+    }
+
+    // Both bilerp and bicubic use bilinear filtering and so need to be clamped to the center
+    // of the edge texel. Pinning to the texel center has no impact on nearest mode and MIP-maps
+
+    static const SkScalar kDomainInset = 0.5f;
+    // Figure out the limits of pixels we're allowed to sample from.
+    // Unless we know the amount of outset and the texture matrix we have to conservatively enforce
+    // the domain.
+    if (restrictFilterToRect) {
+        domainRect->fLeft = constraintRect.fLeft + kDomainInset;
+        domainRect->fTop = constraintRect.fTop + kDomainInset;
+        domainRect->fRight = constraintRect.fRight - kDomainInset;
+        domainRect->fBottom = constraintRect.fBottom - kDomainInset;
+    } else if (textureContentArea) {
+        // If we got here then: there is a textureContentArea, the coords are limited to the
+        // constraint rect, and we're allowed to filter across the constraint rect boundary. So
+        // we check whether the filter would reach across the edge of the content area.
+        bool needContentAreaConstraint = false;
+        // We will only set the sides that are required.
+        domainRect->setLargest();
+        if (textureContentArea->fLeft > 0 &&
+            textureContentArea->fLeft + filterHalfWidth > constraintRect.fLeft) {
+            domainRect->fLeft = textureContentArea->fLeft + kDomainInset;
+            needContentAreaConstraint = true;
+        }
+        if (textureContentArea->fTop > 0 &&
+            textureContentArea->fTop + filterHalfWidth > constraintRect.fTop) {
+            domainRect->fTop = textureContentArea->fTop + kDomainInset;
+            needContentAreaConstraint = true;
+        }

[robertphillips, 2015/11/06 20:54:51]

texW-1 ?

[bsalomon, 2015/11/09 19:35:22]

no, if fRight is equal to texW we don't need a domain, otherwise we may.

+        if (textureContentArea->fRight < texW &&
+            textureContentArea->fRight - filterHalfWidth < constraintRect.fRight) {
+            domainRect->fRight = textureContentArea->fRight - kDomainInset;
+            needContentAreaConstraint = true;
+        }

[robertphillips, 2015/11/06 20:54:51]

texH ?
texH-1 ?

[bsalomon, 2015/11/09 19:35:22]

texH

+        if (textureContentArea->fBottom < texW &&
+            textureContentArea->fBottom - filterHalfWidth < constraintRect.fBottom) {
+            domainRect->fBottom = textureContentArea->fBottom - kDomainInset;
+            needContentAreaConstraint = true;
+        }
+        if (!needContentAreaConstraint) {
+            return kNoDomain_DomainMode;
+        }
+    } else {
+        return kNoDomain_DomainMode;
+    }
+
+    if (domainRect->fLeft > domainRect->fRight) {
+        domainRect->fLeft = domainRect->fRight = SkScalarAve(domainRect->fLeft, domainRect->fRight);
+    }
+    if (domainRect->fTop > domainRect->fBottom) {
+        domainRect->fTop = domainRect->fBottom = SkScalarAve(domainRect->fTop, domainRect->fBottom);
+    }
+    domainRect->fLeft /= texW;
+    domainRect->fTop /= texH;
+    domainRect->fRight /= texW;
+    domainRect->fBottom /= texH;
+    return kDomain_DomainMode;
+}
+
+const GrFragmentProcessor* GrTextureAdjuster::createFragmentProcessor(
+                                        const SkMatrix& textureMatrix,
+                                        const SkRect& constraintRect,
+                                        FilterConstraint filterConstraint,
+                                        bool coordsLimitedToConstraintRect,
+                                        const GrTextureParams::FilterMode* filterOrNullForBicubic) {
+
+    const SkIRect* contentArea = this->contentAreaOrNull();
+
+    SkRect domain;
+    GrTexture* texture = this->originalTexture();
+    DomainMode domainMode =
+        determine_domain_mode(constraintRect, filterConstraint, coordsLimitedToConstraintRect,
+                              texture->width(), texture->height(),
+                              contentArea, filterOrNullForBicubic,
+                              &domain);
+    if (kTightCopy_DomainMode == domainMode) {
+        // TODO: Copy the texture and adjust the texture matrix (both parts need to consider
+        // non-int constraint rect)
+        // For now: treat as bilerp and ignore what goes on above level 0.
+        SkASSERT(filterOrNullForBicubic &&
+                 GrTextureParams::kMipMap_FilterMode == *filterOrNullForBicubic);
+        static const GrTextureParams::FilterMode kBilerp = GrTextureParams::kBilerp_FilterMode;
+        domainMode =
+            determine_domain_mode(constraintRect, filterConstraint, coordsLimitedToConstraintRect,
+                                  texture->width(), texture->height(),
+                                  contentArea, &kBilerp, &domain);
+        SkASSERT(kTightCopy_DomainMode != domainMode);
+        filterOrNullForBicubic = &kBilerp;
+    }
+    SkASSERT(kNoDomain_DomainMode == domainMode ||
+             (domain.fLeft <= domain.fRight && domain.fTop <= domain.fBottom));
+    if (filterOrNullForBicubic) {
+        if (kDomain_DomainMode == domainMode) {

[robertphillips, 2015/11/06 20:54:51]

// All mipmapped textures should be tight (and not have a domain)
?

[bsalomon, 2015/11/09 19:35:22]

Done.

+            SkASSERT(*filterOrNullForBicubic != GrTextureParams::kMipMap_FilterMode);
+            return GrTextureDomainEffect::Create(texture, textureMatrix, domain,
+                                                 GrTextureDomain::kClamp_Mode,
+                                                 *filterOrNullForBicubic);
+        } else {
+            GrTextureParams params(SkShader::kClamp_TileMode, *filterOrNullForBicubic);
+            return GrSimpleTextureEffect::Create(texture, textureMatrix, params);
+        }
+    } else {
+        if (kDomain_DomainMode == domainMode) {
+            return GrBicubicEffect::Create(texture, textureMatrix, domain);
+        } else {
+            static const SkShader::TileMode kClampClamp[] =
+            { SkShader::kClamp_TileMode, SkShader::kClamp_TileMode };
+            return GrBicubicEffect::Create(texture, textureMatrix, kClampClamp);
+        }
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrTextureMaker::refTextureForParams(GrContext* ctx, const GrTextureParams& params) {
     CopyParams copyParams;
     if (!ctx->getGpu()->makeCopyForTextureParams(this->width(), this->height(), params,
                                                  &copyParams)) {
         return this->refOriginalTexture(ctx);
     }
     GrUniqueKey copyKey;
     this->makeCopyKey(copyParams, &copyKey);
@@ skipping 16 matching lines @@
     return result;
 }
 
 GrTexture* GrTextureMaker::generateTextureForParams(GrContext* ctx, const CopyParams& copyParams) {
     SkAutoTUnref<GrTexture> original(this->refOriginalTexture(ctx));
     if (!original) {
         return nullptr;
     }
     return copy_on_gpu(original, nullptr, copyParams);
 }