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::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;
     bool clamp_clamp = SkShader::kClamp_TileMode == fTileModeX &&
                        SkShader::kClamp_TileMode == fTileModeY;
 
     if (clamp_clamp || trivial_matrix) {
         m = &inv;
     } else {
         fUnitInvMatrix = inv;
         fUnitInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
         m = &fUnitInvMatrix;
     }
 
     fBitmap = &fOrigBitmap;
-    if (fOrigBitmap.hasMipMap()) {
-        int shift = fOrigBitmap.extractMipLevel(&fMipBitmap,
+
+    // Check to see if the transformation matrix is scaling up, and if 
+    // the matrix is simple, and if the paint has high quality scaling 
+    // turned on.  If so, do the bitmap scale here and remove the scaling component from the matrix.
+
+    uint32_t hqUpsampleMask = SkPaint::kFilterBitmap_Flag
+                            | SkPaint::kHighQualityFilterBitmap_Flag
+                              ;
+    if (inv.getType() == (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
+        (inv.getScaleX() < 1 || inv.getScaleY() < 1) &&
+        ((paint.getFlags() & hqUpsampleMask) == hqUpsampleMask) &&
+        fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
+
+        // All the criteria are met; let's make a new bitmap.
+        fScaledBitmap.setConfig(SkBitmap::kARGB_8888_Config, fOrigBitmap.width() / inv.getScaleX(), fOrigBitmap.height() / inv.getScaleY());

[reed1, 2013/07/11 15:43:42]

nit: line-wrap

[reed1, 2013/07/11 15:49:08]

grrrr, this is tricky, since we have one predicate to decide if we should create
fScaledBitmap, and a (potentially) different one to decide if we should actually
create/use a HQ filter...

[humper, 2013/07/11 16:03:03]

Done.

+        fScaledBitmap.allocPixels();
+        fOrigBitmap.scale(&fScaledBitmap);
+        fBitmap = &fScaledBitmap;
+        
+        // Now get rid of the scale factor from the matrix
+        
+        if (m != &fUnitInvMatrix) {
+            fUnitInvMatrix = *m;
+            m = &fUnitInvMatrix;
+        }
+
+        // set the inv matrix type to translate-only; this should have
+        // the side-effect of disabling bitmap filtering also.
+
+        fUnitInvMatrix.setTranslate( 1/m->getScaleX() * m->getTranslateX(), 1/m->getScaleY() * m->getTranslateY() );

[reed1, 2013/07/11 15:43:42]

nit: line-wrap

[humper, 2013/07/11 16:03:03]

Done.

+    } else if (!fBitmap->hasMipMap()) {        
+        // Check to see if the transformation matrix is scaling *down*.
+        // If so, automatically build mipmaps
+    
+        SkPoint v1, v2;
+    
+        // guess if the matrix is scaling down by seeing what it does to two unit vectors.
+    
+        v1.fX = inv.getScaleX();
+        v1.fY = inv.getSkewY();
+        
+        v2.fX = inv.getSkewX();
+        v2.fY = inv.getScaleY();
+        
+        if (v1.fX * v1.fX + v1.fY * v1.fY > 1 ||
+            v2.fX * v2.fX + v2.fY * v2.fY > 1) {
+            fBitmap->buildMipMap();
+        }
+    } 
+    
+    if (fBitmap->hasMipMap()) {
+        int shift = fBitmap->extractMipLevel(&fMipBitmap,
                                                 SkScalarToFixed(m->getScaleX()),
                                                 SkScalarToFixed(m->getSkewY()));
 
         if (shift > 0) {
             if (m != &fUnitInvMatrix) {
                 fUnitInvMatrix = *m;
                 m = &fUnitInvMatrix;
             }
 
             SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
@@ skipping 25 matching lines @@
 
     fInvMatrix      = m;
     fInvProc        = m->getMapXYProc();
     fInvType        = m->getType();
     fInvSx          = SkScalarToFixed(m->getScaleX());
     fInvSxFractionalInt = SkScalarToFractionalInt(m->getScaleX());
     fInvKy          = SkScalarToFixed(m->getSkewY());
     fInvKyFractionalInt = SkScalarToFractionalInt(m->getSkewY());
 
     fAlphaScale = SkAlpha255To256(paint.getAlpha());
+    
+    fShaderProc32 = NULL;
+    fShaderProc16 = NULL;
+    fSampleProc32 = NULL;
+    fSampleProc16 = NULL;
 
     // 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;
+    
+    fFilterQuality = kNone_BitmapFilter;
+    
+    if (paint.isFilterBitmap()) {        
+        if ((paint.getFlags() & hqUpsampleMask) == hqUpsampleMask) {
+            // The paint wants high quality sampling, so let's try to do it.
+            fFilterQuality = kHQ_BitmapFilter;
+            fShaderProc32 = this->chooseBitmapFilterProc();
+        }
+        
+        if (!fShaderProc32) {
+            // if no shader proc is set, either the caller didn't ask
+            // for high quality filtering (so we didn't try at all),
+            // or our attempt to install an HQ sampler failed.  
+            // Attempt to use bilerp in either case.
+            
+            // Only install bilerp if the matrix is "interesting" and
+            // the image has a suitable size.
+            
+            if (fInvType > SkMatrix::kTranslate_Mask &&

[reed1, 2013/07/11 15:43:42]

Shouldn't we perform this (not scaled enough to justify any filtering) test
*before* we create a HQ proc?

[reed1, 2013/07/11 15:49:08]

Ah, I see that you are *re*calling this logic after you've (potentially) changed
fBitmap to point to a scaled version. Good. Perhaps we could refactor to make
this clearer (and also perhaps we should do this 2nd-pass logic in the miplevel
case as well.

[humper, 2013/07/11 16:03:03]

the valid_for_filtering function actually checks to make sure the image isn't
too huge, I think :)

However, you're right, we shouldn't install the HQ proc if the matrix is
translate only or simpler.  the chooseBitmapFilterProc() function in
SkBitmapFilter will actually do that by making sure that the matrix is either
affine or scale, so the right thing is actually happening.

+             valid_for_filtering(fBitmap->width() | fBitmap->height())) {
+                 fFilterQuality = kBilerp_BitmapFilter;
+             }
+        }
+    }
 
     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) {
+    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;
@@ skipping 96 matching lines @@
             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);
     }
 
     if (NULL == fShaderProc32) {
         fShaderProc32 = this->chooseShaderProc32();
     }
 
-    if (NULL == fShaderProc32) {
-        fShaderProc32 = this->chooseBitmapFilterProc(paint);
-    }
-
     // 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(s.fFilterQuality == kNone_BitmapFilter);
 
     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(s.fFilterQuality == kNone_BitmapFilter);

[reed1, 2013/07/11 15:43:42]

nit: skia likes to place the literal on the left (but not so important when the
var is const I guess)

 
     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 (fFilterQuality == kNone_BitmapFilter && 
+            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;
 }