stop using bitmap-filter flags outside of paint itself, as a step towards really changing them into…

src/core/SkBitmapProcState.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 "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
@@ skipping 73 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool valid_for_filtering(unsigned dimension) {
     // for filtering, width and height must fit in 14bits, since we use steal
     // 2 bits from each to store our 4bit subpixel data
     return (dimension & ~0x3FFF) == 0;
 }
 
+static bool effective_matrix_scale_sqrd(const SkMatrix& mat) {
+    SkPoint v1, v2;
+    
+    v1.fX = mat.getScaleX();
+    v1.fY = mat.getSkewY();
+    
+    v2.fX = mat.getSkewX();
+    v2.fY = mat.getScaleY();
+    
+    return SkMaxScalar(v1.lengthSqd(), v2.lengthSqd());
+}
+
 // TODO -- we may want to pass the clip into this function so we only scale
 // the portion of the image that we're going to need.  This will complicate
 // the interface to the cache, but might be well worth it.
 
 void SkBitmapProcState::possiblyScaleImage() {
 
-    if (fFilterQuality != kHQ_BitmapFilter) {
+    if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
+        // none or low (bilerp) does not need to look any further
         return;
     }
 
     // see if our platform has any specialized convolution code.
 
 
     // Set up a pointer to a local (instead of storing the structure in the
     // proc state) to avoid introducing a header dependency; this makes
     // recompiles a lot less painful.
 
     SkConvolutionProcs simd;
     fConvolutionProcs = &simd;
 
     fConvolutionProcs->fExtraHorizontalReads = 0;
     fConvolutionProcs->fConvolveVertically = NULL;
     fConvolutionProcs->fConvolve4RowsHorizontally = NULL;
     fConvolutionProcs->fConvolveHorizontally = NULL;
     fConvolutionProcs->fApplySIMDPadding = NULL;
 
     this->platformConvolutionProcs();
 
     // STEP 1: Highest quality direct scale?
 
     // Check to see if the transformation matrix is simple, and if we're
     // doing high quality scaling.  If so, do the bitmap scale here and
     // remove the scaling component from the matrix.
 
-    if (fFilterQuality == kHQ_BitmapFilter &&
+    if (SkPaint::kHigh_FilterLevel == fFilterLevel &&
         fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
         fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
 
         int dest_width  = SkScalarCeilToInt(fOrigBitmap.width() / fInvMatrix.getScaleX());
         int dest_height = SkScalarCeilToInt(fOrigBitmap.height() / fInvMatrix.getScaleY());
 
         // All the criteria are met; let's make a new bitmap.
 
         fScaledBitmap = SkBitmapScaler::Resize( fOrigBitmap, SkBitmapScaler::RESIZE_BEST,
                                                 dest_width, dest_height, fConvolutionProcs );
 
         fScaledBitmap.lockPixels();
 
         fBitmap = &fScaledBitmap;
 
         // set the inv matrix type to translate-only;
 
         fInvMatrix.setTranslate( 1/fInvMatrix.getScaleX() * fInvMatrix.getTranslateX(),
                                  1/fInvMatrix.getScaleY() * fInvMatrix.getTranslateY() );
 
         // no need for any further filtering; we just did it!
 
-        fFilterQuality = kNone_BitmapFilter;
+        fFilterLevel = SkPaint::kNone_FilterLevel;
 
         return;
     }
 
-    if (!fOrigBitmap.hasMipMap() && fFilterQuality != kNone_BitmapFilter) {
+    /*
+     *  If we get here, the caller has requested either Med or High filter-level
+     *
+     *  If High, then our special-case for scale-only did not take, and so we
+     *  have to make a choice:
+     *      1. fall back on mipmaps + bilerp
+     *      2. fall back on scanline bicubic filter
+     *  For now, we compute the "scale" value from the matrix, and have a
+     *  threshold to decide when bicubic is better, and when mips are better.
+     *  No doubt a fancier decision tree could be used uere.
+     *
+     *  If Medium, then we just try to build a mipmap and select a level,
+     *  setting the filter-level to kLow to signal that we just need bilerp
+     *  to process the selected level.
+     */
 
-        // STEP 2: MIPMAP DOWNSAMPLE?
+    SkScalar scaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
 
-        // Check to see if the transformation matrix is scaling *down*.
-        // If so, automatically build mipmaps.
+    if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
+        // Set the limit at 0.25 for the CTM... if the CTM is scaling smaller
+        // than this, then the mipmaps quality may be greater (certainly faster)
+        // so we only keep High quality if the scale is greater than this.
+        //
+        // Since we're dealing with the inverse, we compare against its inverse.
+        const SkScalar bicubicLimit = SkFloatToScalar(4.0f);
+        const SkScalar bicubicLimitSqd = bicubicLimit * bicubicLimit;
+        if (scaleSqd < bicubicLimitSqd) {  // use bicubic scanline
+            return;
+        }
 
-        SkPoint v1, v2;
+        // else set the filter-level to Medium, since we're scaling down and
+        // want to reqeust mipmaps
+        fFilterLevel = SkPaint::kMedium_FilterLevel;
+    }
+    
+    SkASSERT(SkPaint::kMedium_FilterLevel == fFilterLevel);
 
-        // conservatively estimate if the matrix is scaling down by seeing
-        // what its upper left 2x2 portion does to two unit vectors.
-
-        v1.fX = fInvMatrix.getScaleX();
-        v1.fY = fInvMatrix.getSkewY();
-
-        v2.fX = fInvMatrix.getSkewX();
-        v2.fY = fInvMatrix.getScaleY();
-
-        if (v1.fX * v1.fX + v1.fY * v1.fY > 1 ||
-            v2.fX * v2.fX + v2.fY * v2.fY > 1) {
+    /**
+     *  Medium quality means use a mipmap for down-scaling, and just bilper
+     *  for upscaling. Since we're examining the inverse matrix, we look for
+     *  a scale > 1 to indicate down scaling by the CTM.
+     */
+    if (scaleSqd > SK_Scalar1) {
+        if (!fOrigBitmap.hasMipMap()) {
             fOrigBitmap.buildMipMap();
-
-            // Now that we've built the mipmaps and we know we're downsampling,
-            // downgrade to bilinear interpolation for the mip level.
-
-            fFilterQuality = kBilerp_BitmapFilter;
+            // build may fail, so we need to check again
+        }
+        if (fOrigBitmap.hasMipMap()) {
+            int shift = fOrigBitmap.extractMipLevel(&fScaledBitmap,
+                                        SkScalarToFixed(fInvMatrix.getScaleX()),
+                                        SkScalarToFixed(fInvMatrix.getSkewY()));
+            if (shift > 0) {
+                SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
+                fInvMatrix.postScale(scale, scale);
+                fBitmap = &fScaledBitmap;
+            }
         }
     }
 
-    if (fOrigBitmap.hasMipMap()) {
-
-        // STEP 3: We've got mipmaps, let's choose the closest level as our render
-        // source and adjust the matrix accordingly.
-
-        int shift = fOrigBitmap.extractMipLevel(&fScaledBitmap,
-                                                SkScalarToFixed(fInvMatrix.getScaleX()),
-                                                SkScalarToFixed(fInvMatrix.getSkewY()));
-
-        if (shift > 0) {
-            SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
-            fInvMatrix.postScale(scale, scale);
-            fBitmap = &fScaledBitmap;
-        }
-    }
+    // Now that we've built the mipmaps (if applicable), we set the filter-level
+    // bilinear interpolation.
+    fFilterLevel = SkPaint::kLow_FilterLevel;
 }
 
 void SkBitmapProcState::endContext() {
     SkDELETE(fBitmapFilter);
     fBitmapFilter = NULL;
     fScaledBitmap.reset();
 }
 
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     if (fOrigBitmap.width() == 0 || fOrigBitmap.height() == 0) {
         return false;
     }
 
     bool trivialMatrix = (inv.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                        SkShader::kClamp_TileMode == fTileModeY;
 
     fInvMatrix = inv;
     if (!(clampClamp || trivialMatrix)) {
         fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
     }
 
     fBitmap = &fOrigBitmap;
 
     // initialize our filter quality to the one requested by the caller.
     // We may downgrade it later if we determine that we either don't need
     // or can't provide as high a quality filtering as the user requested.
 
-    fFilterQuality = kNone_BitmapFilter;
-    if (paint.isFilterBitmap()) {
-        if (paint.getFlags() & SkPaint::kHighQualityFilterBitmap_Flag) {
-            fFilterQuality = kHQ_BitmapFilter;
-        } else {
-            fFilterQuality = kBilerp_BitmapFilter;
-        }
-    }
+    fFilterLevel = paint.getFilterLevel();
 
 #ifndef SK_IGNORE_IMAGE_PRESCALE
     // possiblyScaleImage will look to see if it can rescale the image as a
     // preprocess; either by scaling up to the target size, or by selecting
     // a nearby mipmap level.  If it does, it will adjust the working
     // matrix as well as the working bitmap.  It may also adjust the filter
     // quality to avoid re-filtering an already perfectly scaled image.
 
     this->possiblyScaleImage();
 #endif
@@ skipping 31 matching lines @@
     fShaderProc32 = NULL;
     fShaderProc16 = NULL;
     fSampleProc32 = NULL;
     fSampleProc16 = NULL;
 
     // recompute the triviality of the matrix here because we may have
     // changed it!
 
     trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
 
-    if (kHQ_BitmapFilter == fFilterQuality) {
+    if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
         // If this is still set, that means we wanted HQ sampling
         // but couldn't do it as a preprocess.  Let's try to install
         // the scanline version of the HQ sampler.  If that process fails,
         // downgrade to bilerp.
 
         // NOTE: Might need to be careful here in the future when we want
         // to have the platform proc have a shot at this; it's possible that
         // the chooseBitmapFilterProc will fail to install a shader but a
         // platform-specific one might succeed, so it might be premature here
         // to fall back to bilerp.  This needs thought.
 
         SkASSERT(fInvType > SkMatrix::kTranslate_Mask);
 
         fShaderProc32 = this->chooseBitmapFilterProc();
         if (!fShaderProc32) {
-            fFilterQuality = kBilerp_BitmapFilter;
+            fFilterLevel = SkPaint::kLow_FilterLevel;
         }
     }
 
-    if (kBilerp_BitmapFilter == fFilterQuality) {
+    if (SkPaint::kLow_FilterLevel == fFilterLevel) {
         // Only try bilerp if the matrix is "interesting" and
         // the image has a suitable size.
 
         if (fInvType <= SkMatrix::kTranslate_Mask ||
-            !valid_for_filtering(fBitmap->width() | fBitmap->height())) {
-                 fFilterQuality = kNone_BitmapFilter;
+                !valid_for_filtering(fBitmap->width() | fBitmap->height())) {
+            fFilterLevel = SkPaint::kNone_FilterLevel;
         }
     }
 
     // At this point, we know exactly what kind of sampling the per-scanline
     // shader will perform.
 
     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
     if (NULL == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
 
     // No need to do this if we're doing HQ sampling; if filter quality is
     // still set to HQ by the time we get here, then we must have installed
     // the shader proc above and can skip all this.
 
-    if (fFilterQuality < kHQ_BitmapFilter) {
+    if (fFilterLevel < SkPaint::kHigh_FilterLevel) {
 
         int index = 0;
         if (fAlphaScale < 256) {  // note: this distinction is not used for D16
             index |= 1;
         }
         if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
             index |= 2;
         }
-        if (fFilterQuality != kNone_BitmapFilter) {
+        if (fFilterLevel > SkPaint::kNone_FilterLevel) {
             index |= 4;
         }
         // bits 3,4,5 encoding the source bitmap format
         switch (fBitmap->config()) {
             case SkBitmap::kARGB_8888_Config:
                 index |= 0;
                 break;
             case SkBitmap::kRGB_565_Config:
                 index |= 8;
                 break;
@@ skipping 110 matching lines @@
     return true;
 }
 
 static void Clamp_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
                                                     int x, int y,
                                                     SkPMColor* SK_RESTRICT colors,
                                                     int count) {
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
-    SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality);
+    SkASSERT(SkPaint::kNone_FilterLevel == s.fFilterLevel);
 
     const int maxX = s.fBitmap->width() - 1;
     const int maxY = s.fBitmap->height() - 1;
     int ix = s.fFilterOneX + x;
     int iy = SkClampMax(s.fFilterOneY + y, maxY);
 #ifdef SK_DEBUG
     {
         SkPoint pt;
         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
@@ skipping 53 matching lines @@
     return x;
 }
 
 static void Repeat_S32_D32_nofilter_trans_shaderproc(const SkBitmapProcState& s,
                                                      int x, int y,
                                                      SkPMColor* SK_RESTRICT colors,
                                                      int count) {
     SkASSERT(((s.fInvType & ~SkMatrix::kTranslate_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
-    SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality);
+    SkASSERT(SkPaint::kNone_FilterLevel == s.fFilterLevel);
 
     const int stopX = s.fBitmap->width();
     const int stopY = s.fBitmap->height();
     int ix = s.fFilterOneX + x;
     int iy = sk_int_mod(s.fFilterOneY + y, stopY);
 #ifdef SK_DEBUG
     {
         SkPoint pt;
         s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                    SkIntToScalar(y) + SK_ScalarHalf, &pt);
@@ skipping 25 matching lines @@
                                       int count) {
     SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) == 0);
     SkASSERT(s.fInvKy == 0);
     SkASSERT(count > 0 && colors != NULL);
     SkASSERT(1 == s.fBitmap->width());
 
     int iY0;
     int iY1   SK_INIT_TO_AVOID_WARNING;
     int iSubY SK_INIT_TO_AVOID_WARNING;
 
-    if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) {
+    if (SkPaint::kNone_FilterLevel != s.fFilterLevel) {
         SkBitmapProcState::MatrixProc mproc = s.getMatrixProc();
         uint32_t xy[2];
 
         mproc(s, xy, 1, x, y);
 
         iY0 = xy[0] >> 18;
         iY1 = xy[0] & 0x3FFF;
         iSubY = (xy[0] >> 14) & 0xF;
     } else {
         int yTemp;
@@ skipping 60 matching lines @@
             }
 
             SkASSERT(iY0 == iY2);
         }
 #endif
     }
 
     const SkPMColor* row0 = s.fBitmap->getAddr32(0, iY0);
     SkPMColor color;
 
-    if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) {
+    if (SkPaint::kNone_FilterLevel != s.fFilterLevel) {
         const SkPMColor* row1 = s.fBitmap->getAddr32(0, iY1);
 
         if (s.fAlphaScale < 256) {
             Filter_32_alpha(iSubY, *row0, *row1, &color, s.fAlphaScale);
         } else {
             Filter_32_opaque(iSubY, *row0, *row1, &color);
         }
     } else {
         if (s.fAlphaScale < 256) {
             color = SkAlphaMulQ(*row0, s.fAlphaScale);
@@ skipping 35 matching lines @@
 
 SkBitmapProcState::ShaderProc32 SkBitmapProcState::chooseShaderProc32() {
 
     if (SkBitmap::kARGB_8888_Config != fBitmap->config()) {
         return NULL;
     }
 
     static const unsigned kMask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
 
     if (1 == fBitmap->width() && 0 == (fInvType & ~kMask)) {
-        if (kNone_BitmapFilter == fFilterQuality &&
+        if (SkPaint::kNone_FilterLevel == fFilterLevel &&
             fInvType <= SkMatrix::kTranslate_Mask &&
             !this->setupForTranslate()) {
             return DoNothing_shaderproc;
         }
         return S32_D32_constX_shaderproc;
     }
 
     if (fAlphaScale < 256) {
         return NULL;
     }
     if (fInvType > SkMatrix::kTranslate_Mask) {
         return NULL;
     }
-    if (fFilterQuality != kNone_BitmapFilter) {
+    if (SkPaint::kNone_FilterLevel != fFilterLevel) {
         return NULL;
     }
 
     SkShader::TileMode tx = (SkShader::TileMode)fTileModeX;
     SkShader::TileMode ty = (SkShader::TileMode)fTileModeY;
 
     if (SkShader::kClamp_TileMode == tx && SkShader::kClamp_TileMode == ty) {
         if (this->setupForTranslate()) {
             return Clamp_S32_D32_nofilter_trans_shaderproc;
         }
@@ skipping 75 matching lines @@
     SkASSERT(count > 0);
 
     state.fMatrixProc(state, bitmapXY, count, x, y);
 
     void (*proc)(uint32_t bitmapXY[], int count, unsigned mx, unsigned my);
 
     // There are four formats possible:
     //  scale -vs- affine
     //  filter -vs- nofilter
     if (state.fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
-        proc = state.fFilterQuality != kNone_BitmapFilter ? check_scale_filter : check_scale_nofilter;
+        proc = state.fFilterLevel != SkPaint::kNone_FilterLevel ? check_scale_filter : check_scale_nofilter;
     } else {
-        proc = state.fFilterQuality != kNone_BitmapFilter ? check_affine_filter : check_affine_nofilter;
+        proc = state.fFilterLevel != SkPaint::kNone_FilterLevel ? check_affine_filter : check_affine_nofilter;
     }
     proc(bitmapXY, count, state.fBitmap->width(), state.fBitmap->height());
 }
 
 SkBitmapProcState::MatrixProc SkBitmapProcState::getMatrixProc() const {
     return DebugMatrixProc;
 }
 
 #endif
 
@@ skipping 14 matching lines @@
     if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
         size -= 4;   // the shared Y (or YY) coordinate
         if (size < 0) {
             size = 0;
         }
         size >>= 1;
     } else {
         size >>= 2;
     }
 
-    if (fFilterQuality != kNone_BitmapFilter) {
+    if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }