Centralize decision about whether to do bicubic filtering, and fallbacks to mip, bilerp, or nearest

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 "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
@@ skipping 364 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.getMinScale();
-    } else {
-        SkMatrix combined;
-        combined.setConcat(viewMatrix, localMatrix);
-        return combined.getMinScale();
-    }
-}
-
 GrEffectRef* SkBitmapProcShader::asNewEffect(GrContext* context, const SkPaint& paint,
                                              const SkMatrix* localMatrix) const {
     SkMatrix matrix;
     matrix.setIDiv(fRawBitmap.width(), fRawBitmap.height());
 
     SkMatrix lmInverse;
     if (!this->getLocalMatrix().invert(&lmInverse)) {
         return NULL;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
             return NULL;
         }
         lmInverse.postConcat(inv);
     }
     matrix.preConcat(lmInverse);
 
     SkShader::TileMode tm[] = {
         (TileMode)fTileModeX,
         (TileMode)fTileModeY,
     };
 
     // 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();
+    bool useBicubic = false;
     GrTextureParams::FilterMode textureFilterMode;
-    switch(paintFilterLevel) {
+    switch(paint.getFilterLevel()) {
         case SkPaint::kNone_FilterLevel:
             textureFilterMode = GrTextureParams::kNone_FilterMode;
             break;
         case SkPaint::kLow_FilterLevel:
             textureFilterMode = GrTextureParams::kBilerp_FilterMode;
             break;
-        case SkPaint::kMedium_FilterLevel:
-            if (get_combined_min_stretch(context->getMatrix(), this->getLocalMatrix()) <
-                SK_Scalar1) {
+        case SkPaint::kMedium_FilterLevel: {
+            SkMatrix matrix;
+            matrix.setConcat(context->getMatrix(), this->getLocalMatrix());
+            if (matrix.getMinScale() < 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 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.
-                paintFilterLevel = SkPaint::kMedium_FilterLevel;
-                textureFilterMode = GrTextureParams::kMipMap_FilterMode;
-            }
+        }
+        case SkPaint::kHigh_FilterLevel: {
+            SkMatrix matrix;
+            matrix.setConcat(context->getMatrix(), this->getLocalMatrix());
+            useBicubic = GrBicubicEffect::ShouldUseBicubic(matrix, &textureFilterMode);
             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;
             break;
 
     }
     GrTextureParams params(tm, textureFilterMode);
     GrTexture* texture = GrLockAndRefCachedBitmapTexture(context, fRawBitmap, &params);
 
     if (NULL == texture) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "Couldn't convert bitmap to texture.");
         return NULL;
     }
 
     GrEffectRef* effect = NULL;
-    if (paintFilterLevel == SkPaint::kHigh_FilterLevel) {
+    if (useBicubic) {
         effect = GrBicubicEffect::Create(texture, matrix, tm);
     } else {
         effect = GrSimpleTextureEffect::Create(texture, matrix, params);
     }
     GrUnlockAndUnrefCachedBitmapTexture(texture);
     return effect;
 }
 #endif