Working plumb of image scaling:

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 72 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;
 }
 
+void SkBitmapProcState::possiblyScaleImage() {

[reed1, 2013/07/12 14:01:06]

I think we may need to pass in the clip-bounds, so we can allocate/scale a
minimal subset of the src bitmap in the case where it is clipped. Naturally,
this will complicate (yet more) any caching scheme, but we know we see very
large images sometimes that are only used partially.

[humper, 2013/07/12 17:18:01]

Is it OK to leave this as a TODO comment for now and file a bug against
ourselves?

+
+    if (fFilterQuality != kHQ_BitmapFilter) {
+        return;
+    }
+
+    // STEP 1: UPSAMPLE?
+
+    // Check to see if the transformation matrix is scaling up, and if 
+    // the 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 (fUnitInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
+        (fUnitInvMatrix.getScaleX() < 1 || fUnitInvMatrix.getScaleY() < 1) &&
+        fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
+            
+        // All the criteria are met; let's make a new bitmap.
+        fScaledBitmap.setConfig(SkBitmap::kARGB_8888_Config, 
+                                (int)(fOrigBitmap.width() / fUnitInvMatrix.getScaleX()), 
+                                (int)(fOrigBitmap.height() / fUnitInvMatrix.getScaleY()));
+        fScaledBitmap.allocPixels();
+        fOrigBitmap.scale(&fScaledBitmap);
+        fBitmap = &fScaledBitmap;
+        
+        // set the inv matrix type to translate-only;
+
+        fUnitInvMatrix.setTranslate( 1/fUnitInvMatrix.getScaleX() * fUnitInvMatrix.getTranslateX(), 
+                                     1/fUnitInvMatrix.getScaleY() * fUnitInvMatrix.getTranslateY() );
+        
+        // no need for any further filtering; we just did it!
+                                     
+        fFilterQuality = kNone_BitmapFilter;
+        
+        return;
+    } 
+    
+    if (!fOrigBitmap.hasMipMap()) {        
+        
+        // STEP 2: DOWNSAMPLE
+        
+        // Check to see if the transformation matrix is scaling *down*.
+        // If so, automatically build mipmaps. 
+    
+        SkPoint v1, v2;
+    
+        // conservatively estimate if the matrix is scaling down by seeing 
+        // what its upper left 2x2 portion does to two unit vectors.
+    
+        v1.fX = fUnitInvMatrix.getScaleX();
+        v1.fY = fUnitInvMatrix.getSkewY();
+                
+        v2.fX = fUnitInvMatrix.getSkewX();
+        v2.fY = fUnitInvMatrix.getScaleY();
+        
+        if (v1.fX * v1.fX + v1.fY * v1.fY > 1 ||
+            v2.fX * v2.fX + v2.fY * v2.fY > 1) {
+            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;
+        }        
+    } 
+    
+    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(fUnitInvMatrix.getScaleX()),
+                                                SkScalarToFixed(fUnitInvMatrix.getSkewY()));
+
+        if (shift > 0) {
+            SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
+            fUnitInvMatrix.postScale(scale, scale);
+            fBitmap = &fScaledBitmap;
+        }
+    }
+}
+
+void SkBitmapProcState::endContext() {
+    SkDELETE(fBitmapFilter);
+}
+
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     if (fOrigBitmap.width() == 0 || fOrigBitmap.height() == 0) {
         return false;
     }
 
-    const SkMatrix* m;
     bool trivial_matrix = (inv.getType() & ~SkMatrix::kTranslate_Mask) == 0;

[reed1, 2013/07/12 14:01:06]

This is probably too soon to be computing "trivialness" of the matrix, since we
may change the matrix later on... See the users of trivial_matrix below.

[humper, 2013/07/12 17:18:01]

trivial_matrix is used immediately (so we need it now), to do a div by the width
and height of the image, and also later in choosing the matrix proc.  Should we
recompute it before its later use?

[reed1, 2013/07/12 18:33:24]

Yes, lets recompute it, either when we know we've changed fInvMatrix, or right
before we need it again (since it is so easy to compute). Probably a 1-line
helper function to encapsulate it like trans_or_identity()

     bool clamp_clamp = SkShader::kClamp_TileMode == fTileModeX &&
                        SkShader::kClamp_TileMode == fTileModeY;
 
-    if (clamp_clamp || trivial_matrix) {
-        m = &inv;
-    } else {
-        fUnitInvMatrix = inv;
+    fUnitInvMatrix = inv;

[reed1, 2013/07/12 14:01:06]

I see now that your change meas we *always* use fUnitInvMatrix, instead of only
as needed. That is probably ok (a tiny bit slower?) but if that is the case,
lets rename it to fInverMatrix or something more general.

[humper, 2013/07/12 17:18:01]

Done.

+    if (!(clamp_clamp || trivial_matrix)) {
         fUnitInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
-        m = &fUnitInvMatrix;
     }
 
     fBitmap = &fOrigBitmap;
-    if (fOrigBitmap.hasMipMap()) {
-        int shift = fOrigBitmap.extractMipLevel(&fMipBitmap,
-                                                SkScalarToFixed(m->getScaleX()),
-                                                SkScalarToFixed(m->getSkewY()));
-
-        if (shift > 0) {
-            if (m != &fUnitInvMatrix) {
-                fUnitInvMatrix = *m;
-                m = &fUnitInvMatrix;
-            }
-
-            SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
-            fUnitInvMatrix.postScale(scale, scale);
-
-            // now point here instead of fOrigBitmap
-            fBitmap = &fMipBitmap;
+    
+    // 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;
         }
     }
 
-    // wack our matrix to exactly no-scale, if we're really close to begin with
-    if (matrix_only_scale_translate(*m)) {
+    // 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.
+    
+    possiblyScaleImage();

[reed1, 2013/07/12 14:01:06]

nit: this->possiblyScaleImage();

[humper, 2013/07/12 17:18:01]

Done.

+    
+    // Now that all possible changes to the matrix have taken place, check
+    // to see if we're really close to a no-scale matrix.  If so, explicitly
+    // set it to be so.  Subsequent code may inspect this matrix to choose
+    // a faster path in this case.
+
+    if (matrix_only_scale_translate(fUnitInvMatrix)) {

[reed1, 2013/07/12 14:01:06]

unrelated to this CL, but this guy should probably only execute if the matrix
has *some* scale. If it is already purely translate, then I think there is not
need to invert and do the trickery. Maybe you can add a comment to that effect.

[humper, 2013/07/12 17:18:01]

Done.

         SkMatrix forward;
-        if (m->invert(&forward)) {
+        if (fUnitInvMatrix.invert(&forward)) {
             if (clamp_clamp ? just_trans_clamp(forward, *fBitmap)
                             : just_trans_general(forward)) {
                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
                 fUnitInvMatrix.setTranslate(tx, ty);
-                m = &fUnitInvMatrix;
-                // now the following code will sniff m, and decide to take the
-                // fast case (since m is purely translate).
+                
             }
         }
     }
 
     // Below this point, we should never refer to the inv parameter, since we
     // may be using a munged version for "our" inverse.
 
-    fInvMatrix      = m;
-    fInvProc        = m->getMapXYProc();
-    fInvType        = m->getType();
-    fInvSx          = SkScalarToFixed(m->getScaleX());
-    fInvSxFractionalInt = SkScalarToFractionalInt(m->getScaleX());
-    fInvKy          = SkScalarToFixed(m->getSkewY());
-    fInvKyFractionalInt = SkScalarToFractionalInt(m->getSkewY());
+    fInvMatrix      = &fUnitInvMatrix;
+    fInvProc        = fInvMatrix->getMapXYProc();

[reed1, 2013/07/12 14:01:06]

Maybe we no longer need fInvMatrix as a pointer anymore, if we are *always*
using a known storage field.

Thus, perhaps we kill this pointer, and rename fUnitInvMatrix to fInvMatrix (and
then use a . instead of a ->)

If that is too hairy for now, lets just add a comment in State.h to that effect
near these two fields.

[humper, 2013/07/12 17:18:01]

Done.

+    fInvType        = fInvMatrix->getType();
+    fInvSx          = SkScalarToFixed(fInvMatrix->getScaleX());
+    fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix->getScaleX());
+    fInvKy          = SkScalarToFixed(fInvMatrix->getSkewY());
+    fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix->getSkewY());
 
     fAlphaScale = SkAlpha255To256(paint.getAlpha());
-
-    // pick-up filtering from the paint, but only if the matrix is
-    // more complex than identity/translate (i.e. no need to pay the cost
-    // of filtering if we're not scaled etc.).
-    // note: we explicitly check inv, since m might be scaled due to unitinv
-    //       trickery, but we don't want to see that for this test
-    fDoFilter = paint.isFilterBitmap() &&
-                (fInvType > SkMatrix::kTranslate_Mask &&
-                 valid_for_filtering(fBitmap->width() | fBitmap->height()));
-
+    
     fShaderProc32 = NULL;
     fShaderProc16 = NULL;
     fSampleProc32 = NULL;
     fSampleProc16 = NULL;
 
+    if (kHQ_BitmapFilter == fFilterQuality) {

[reed1, 2013/07/12 14:01:06]

*maybe* we can add an ASSERT here that claims that the matrix is more
complicated than translate, just to catch any intervening bugs/slips.

[humper, 2013/07/12 17:18:01]

Done.

+        // 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.
+
+        fShaderProc32 = this->chooseBitmapFilterProc();
+        if (!fShaderProc32) {
+            fFilterQuality = kBilerp_BitmapFilter;
+        }        
+    }
+    
+    if (kBilerp_BitmapFilter == fFilterQuality) {
+        // 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;
+        }
+    }
+    
+    // At this point, we know exactly what kind of sampling the per-scanline
+    // shader will perform.
+
     fMatrixProc = this->chooseMatrixProc(trivial_matrix);
     if (NULL == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
 
-    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 (fDoFilter) {
-        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;
-        case SkBitmap::kIndex8_Config:
-            index |= 16;
-            break;
-        case SkBitmap::kARGB_4444_Config:
-            index |= 24;
-            break;
-        case SkBitmap::kA8_Config:
-            index |= 32;
-            fPaintPMColor = SkPreMultiplyColor(paint.getColor());
-            break;
-        default:
-            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 !SK_ARM_NEON_IS_ALWAYS
-    static const SampleProc32 gSkBitmapProcStateSample32[] = {
-        S32_opaque_D32_nofilter_DXDY,
-        S32_alpha_D32_nofilter_DXDY,
-        S32_opaque_D32_nofilter_DX,
-        S32_alpha_D32_nofilter_DX,
-        S32_opaque_D32_filter_DXDY,
-        S32_alpha_D32_filter_DXDY,
-        S32_opaque_D32_filter_DX,
-        S32_alpha_D32_filter_DX,
+    if (fFilterQuality < kHQ_BitmapFilter) {
+        
+        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) {
+            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;
+            case SkBitmap::kIndex8_Config:
+                index |= 16;
+                break;
+            case SkBitmap::kARGB_4444_Config:
+                index |= 24;
+                break;
+            case SkBitmap::kA8_Config:
+                index |= 32;
+                fPaintPMColor = SkPreMultiplyColor(paint.getColor());
+                break;
+            default:
+                return false;
+        }
 
-        S16_opaque_D32_nofilter_DXDY,
-        S16_alpha_D32_nofilter_DXDY,
-        S16_opaque_D32_nofilter_DX,
-        S16_alpha_D32_nofilter_DX,
-        S16_opaque_D32_filter_DXDY,
-        S16_alpha_D32_filter_DXDY,
-        S16_opaque_D32_filter_DX,
-        S16_alpha_D32_filter_DX,
+    #if !SK_ARM_NEON_IS_ALWAYS
+        static const SampleProc32 gSkBitmapProcStateSample32[] = {
+            S32_opaque_D32_nofilter_DXDY,
+            S32_alpha_D32_nofilter_DXDY,
+            S32_opaque_D32_nofilter_DX,
+            S32_alpha_D32_nofilter_DX,
+            S32_opaque_D32_filter_DXDY,
+            S32_alpha_D32_filter_DXDY,
+            S32_opaque_D32_filter_DX,
+            S32_alpha_D32_filter_DX,
 
-        SI8_opaque_D32_nofilter_DXDY,
-        SI8_alpha_D32_nofilter_DXDY,
-        SI8_opaque_D32_nofilter_DX,
-        SI8_alpha_D32_nofilter_DX,
-        SI8_opaque_D32_filter_DXDY,
-        SI8_alpha_D32_filter_DXDY,
-        SI8_opaque_D32_filter_DX,
-        SI8_alpha_D32_filter_DX,
+            S16_opaque_D32_nofilter_DXDY,
+            S16_alpha_D32_nofilter_DXDY,
+            S16_opaque_D32_nofilter_DX,
+            S16_alpha_D32_nofilter_DX,
+            S16_opaque_D32_filter_DXDY,
+            S16_alpha_D32_filter_DXDY,
+            S16_opaque_D32_filter_DX,
+            S16_alpha_D32_filter_DX,
 
-        S4444_opaque_D32_nofilter_DXDY,
-        S4444_alpha_D32_nofilter_DXDY,
-        S4444_opaque_D32_nofilter_DX,
-        S4444_alpha_D32_nofilter_DX,
-        S4444_opaque_D32_filter_DXDY,
-        S4444_alpha_D32_filter_DXDY,
-        S4444_opaque_D32_filter_DX,
-        S4444_alpha_D32_filter_DX,
+            SI8_opaque_D32_nofilter_DXDY,
+            SI8_alpha_D32_nofilter_DXDY,
+            SI8_opaque_D32_nofilter_DX,
+            SI8_alpha_D32_nofilter_DX,
+            SI8_opaque_D32_filter_DXDY,
+            SI8_alpha_D32_filter_DXDY,
+            SI8_opaque_D32_filter_DX,
+            SI8_alpha_D32_filter_DX,
 
-        // A8 treats alpha/opaque the same (equally efficient)
-        SA8_alpha_D32_nofilter_DXDY,
-        SA8_alpha_D32_nofilter_DXDY,
-        SA8_alpha_D32_nofilter_DX,
-        SA8_alpha_D32_nofilter_DX,
-        SA8_alpha_D32_filter_DXDY,
-        SA8_alpha_D32_filter_DXDY,
-        SA8_alpha_D32_filter_DX,
-        SA8_alpha_D32_filter_DX
-    };
+            S4444_opaque_D32_nofilter_DXDY,
+            S4444_alpha_D32_nofilter_DXDY,
+            S4444_opaque_D32_nofilter_DX,
+            S4444_alpha_D32_nofilter_DX,
+            S4444_opaque_D32_filter_DXDY,
+            S4444_alpha_D32_filter_DXDY,
+            S4444_opaque_D32_filter_DX,
+            S4444_alpha_D32_filter_DX,
 
-    static const SampleProc16 gSkBitmapProcStateSample16[] = {
-        S32_D16_nofilter_DXDY,
-        S32_D16_nofilter_DX,
-        S32_D16_filter_DXDY,
-        S32_D16_filter_DX,
+            // A8 treats alpha/opaque the same (equally efficient)
+            SA8_alpha_D32_nofilter_DXDY,
+            SA8_alpha_D32_nofilter_DXDY,
+            SA8_alpha_D32_nofilter_DX,
+            SA8_alpha_D32_nofilter_DX,
+            SA8_alpha_D32_filter_DXDY,
+            SA8_alpha_D32_filter_DXDY,
+            SA8_alpha_D32_filter_DX,
+            SA8_alpha_D32_filter_DX
+        };
 
-        S16_D16_nofilter_DXDY,
-        S16_D16_nofilter_DX,
-        S16_D16_filter_DXDY,
-        S16_D16_filter_DX,
+        static const SampleProc16 gSkBitmapProcStateSample16[] = {
+            S32_D16_nofilter_DXDY,
+            S32_D16_nofilter_DX,
+            S32_D16_filter_DXDY,
+            S32_D16_filter_DX,
 
-        SI8_D16_nofilter_DXDY,
-        SI8_D16_nofilter_DX,
-        SI8_D16_filter_DXDY,
-        SI8_D16_filter_DX,
+            S16_D16_nofilter_DXDY,
+            S16_D16_nofilter_DX,
+            S16_D16_filter_DXDY,
+            S16_D16_filter_DX,
 
-        // Don't support 4444 -> 565
-        NULL, NULL, NULL, NULL,
-        // Don't support A8 -> 565
-        NULL, NULL, NULL, NULL
-    };
-#endif
+            SI8_D16_nofilter_DXDY,
+            SI8_D16_nofilter_DX,
+            SI8_D16_filter_DXDY,
+            SI8_D16_filter_DX,
 
-    fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index];
-    index >>= 1;    // shift away any opaque/alpha distinction
-    fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index];
+            // Don't support 4444 -> 565
+            NULL, NULL, NULL, NULL,
+            // Don't support A8 -> 565
+            NULL, NULL, NULL, NULL
+        };
+    #endif
 
-    // our special-case shaderprocs
-    if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) {
-        if (clamp_clamp) {
-            fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc);
-        } else if (SkShader::kRepeat_TileMode == fTileModeX &&
-                   SkShader::kRepeat_TileMode == fTileModeY) {
-            fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc);
+        fSampleProc32 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample32)[index];
+        index >>= 1;    // shift away any opaque/alpha distinction
+        fSampleProc16 = SK_ARM_NEON_WRAP(gSkBitmapProcStateSample16)[index];
+
+        // our special-case shaderprocs
+        if (SK_ARM_NEON_WRAP(S16_D16_filter_DX) == fSampleProc16) {
+            if (clamp_clamp) {
+                fShaderProc16 = SK_ARM_NEON_WRAP(Clamp_S16_D16_filter_DX_shaderproc);
+            } else if (SkShader::kRepeat_TileMode == fTileModeX &&
+                       SkShader::kRepeat_TileMode == fTileModeY) {
+                fShaderProc16 = SK_ARM_NEON_WRAP(Repeat_S16_D16_filter_DX_shaderproc);
+            }
+        } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clamp_clamp) {
+            fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc);
         }
-    } else if (SK_ARM_NEON_WRAP(SI8_opaque_D32_filter_DX) == fSampleProc32 && clamp_clamp) {
-        fShaderProc32 = SK_ARM_NEON_WRAP(Clamp_SI8_opaque_D32_filter_DX_shaderproc);
-    }
 
-    if (NULL == fShaderProc32) {
-        fShaderProc32 = this->chooseShaderProc32();
-    }
-
-    if (NULL == fShaderProc32) {
-        fShaderProc32 = this->chooseBitmapFilterProc(paint);
+        if (NULL == fShaderProc32) {
+            fShaderProc32 = this->chooseShaderProc32();
+        }
     }
 
     // see if our platform has any accelerated overrides
     this->platformProcs();
 
     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(!s.fDoFilter);
+    SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality);
 
     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(!s.fDoFilter);
+    SkASSERT(SkBitmapProcState::kNone_BitmapFilter == s.fFilterQuality);
 
     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.fDoFilter) {
+    if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) {
         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.fDoFilter) {
+    if (s.fFilterQuality != SkBitmapProcState::kNone_BitmapFilter) {
         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 (!fDoFilter && fInvType <= SkMatrix::kTranslate_Mask && !this->setupForTranslate()) {
+        if (kNone_BitmapFilter == fFilterQuality && 
+            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 (fDoFilter) {
+    if (fFilterQuality != kNone_BitmapFilter) {
         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.fDoFilter ? check_scale_filter : check_scale_nofilter;
+        proc = state.fFilterQuality != kNone_BitmapFilter ? check_scale_filter : check_scale_nofilter;
     } else {
-        proc = state.fDoFilter ? check_affine_filter : check_affine_nofilter;
+        proc = state.fFilterQuality != kNone_BitmapFilter ? 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 (fDoFilter) {
+    if (fFilterQuality != kNone_BitmapFilter) {
         size >>= 1;
     }
 
     return size;
 }