Tweaks in how to apply bitmap filter levels in GPU.

src/core/SkBitmapProcShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkPixelRef.h"
@@ skipping 336 matching lines @@
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrTextureAccess.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "SkGr.h"
 
+// Note that this will return -1 if either matrix is perspective.
+static SkScalar get_combined_min_stretch(const SkMatrix& viewMatrix, const SkMatrix& localMatrix) {
+    if (localMatrix.isIdentity()) {
+        return viewMatrix.getMinStretch();

[reed1, 2013/12/16 21:31:52]

since we detect identity inside setConcat (for both args), can we live w/o
having to check it here too? Just to simplify the code.

+    } else {
+        SkMatrix combined;
+        combined.setConcat(viewMatrix, localMatrix);
+        return combined.getMinStretch();
+    }
+}
+
 GrEffectRef* SkBitmapProcShader::asNewEffect(GrContext* context, const SkPaint& paint) const {
     SkMatrix matrix;
     matrix.setIDiv(fRawBitmap.width(), fRawBitmap.height());
 
-    SkMatrix inverse;
-    if (!this->getLocalMatrix().invert(&inverse)) {
+    SkMatrix lmInverse;
+    if (!this->getLocalMatrix().invert(&lmInverse)) {
         return NULL;
     }
-    matrix.preConcat(inverse);
+    matrix.preConcat(lmInverse);
 
     SkShader::TileMode tm[] = {
         (TileMode)fState.fTileModeX,
         (TileMode)fState.fTileModeY,
     };
 
-    // Must set wrap and filter on the sampler before requesting a texture.
+    // Must set wrap and filter on the sampler before requesting a texture. In two places below
+    // we check the matrix scale factors to determine how to interpret the filter quality setting.
+    // This completely ignores the complexity of the drawVertices case where explicit local coords
+    // are provided by the caller.
     SkPaint::FilterLevel paintFilterLevel = paint.getFilterLevel();
     GrTextureParams::FilterMode textureFilterMode;
     switch(paintFilterLevel) {
         case SkPaint::kNone_FilterLevel:
             textureFilterMode = GrTextureParams::kNone_FilterMode;
             break;
         case SkPaint::kLow_FilterLevel:
             textureFilterMode = GrTextureParams::kBilerp_FilterMode;
             break;
         case SkPaint::kMedium_FilterLevel:
-            textureFilterMode = GrTextureParams::kMipMap_FilterMode;
+            if (get_combined_min_stretch(context->getMatrix(), this->getLocalMatrix()) <

[robertphillips, 2013/12/16 20:41:12]

Wouldn't the real test be if the tri-lerp factor were > ~.1?

[bsalomon, 2013/12/16 20:47:49]

Do you mean allow some small amount of down-scaling before kicking in MIPs?

+                SK_Scalar1) {
+                textureFilterMode = GrTextureParams::kMipMap_FilterMode;
+            } else {
+                // Don't trigger MIP level generation unnecessarily.
+                textureFilterMode = GrTextureParams::kBilerp_FilterMode;
+            }
             break;
         case SkPaint::kHigh_FilterLevel:
-            // Minification can look bad with the bicubic effect. This is an overly aggressive
-            // check for MIP fallbacks. It doesn't consider the fact that minification in the local
-            // matrix could be offset by the view matrix and vice versa. We also don't know whether
-            // the draw has explicit local coords (e.g. drawVertices) where the scale factor is
-            // unknown and varies.
-            if (context->getMatrix().getMinStretch() >= SK_Scalar1 &&
-                this->getLocalMatrix().getMaxStretch() <= SK_Scalar1) {
-                // fall back to no filtering here; we will install another
-                // shader that will do the HQ filtering.
+            // Minification can look bad with bicubic filtering.
+            if (get_combined_min_stretch(context->getMatrix(), this->getLocalMatrix()) >=
+                SK_Scalar1) {
+                // fall back to no filtering here; we will install another shader that will do the
+                // HQ filtering.
                 textureFilterMode = GrTextureParams::kNone_FilterMode;
             } else {
-                // Fall back to mip-mapping.
+                // Fall back to MIP-mapping.
                 paintFilterLevel = SkPaint::kMedium_FilterLevel;
                 textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             }
             break;
         default:
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
@@ skipping 12 matching lines @@
     GrEffectRef* effect = NULL;
     if (paintFilterLevel == SkPaint::kHigh_FilterLevel) {
         effect = GrBicubicEffect::Create(texture, matrix, tm);
     } else {
         effect = GrSimpleTextureEffect::Create(texture, matrix, params);
     }
     GrUnlockAndUnrefCachedBitmapTexture(texture);
     return effect;
 }
 #endif