allow subpixel positioning w/ bitmap filtering

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"
 #include "SkPaint.h"
 #include "SkShader.h"   // for tilemodes
 #include "SkUtilsArm.h"
 #include "SkBitmapScaler.h"
+#include "SkMatrixUtils.h"
 #include "SkMipMap.h"
 #include "SkPixelRef.h"
 #include "SkScaledImageCache.h"
 #include "SkImageEncoder.h"
 
+static int paintfilter_to_subpixelbits(SkPaint::FilterLevel level) {
+    const int gBits[] = { 0, 4, 4, 4, };
+    return gBits[level];
+}
+
 #if !SK_ARM_NEON_IS_NONE
 // These are defined in src/opts/SkBitmapProcState_arm_neon.cpp
 extern const SkBitmapProcState::SampleProc16 gSkBitmapProcStateSample16_neon[];
 extern const SkBitmapProcState::SampleProc32 gSkBitmapProcStateSample32_neon[];
 extern void  S16_D16_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, uint16_t*);
 extern void  Clamp_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
 extern void  Repeat_S16_D16_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint16_t*, int);
 extern void  SI8_opaque_D32_filter_DX_neon(const SkBitmapProcState&, const uint32_t*, int, SkPMColor*);
 extern void  SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int);
 extern void  Clamp_SI8_opaque_D32_filter_DX_shaderproc_neon(const SkBitmapProcState&, int, int, uint32_t*, int);
@@ skipping 337 matching lines @@
     return true;
 }
 
 SkBitmapProcState::~SkBitmapProcState() {
     if (fScaledCacheID) {
         SkScaledImageCache::Unlock(fScaledCacheID);
     }
     SkDELETE(fBitmapFilter);
 }
 
+bool SkBitmapProcState::isInverseTrivial() const {
+    unsigned bits = paintfilter_to_subpixelbits((SkPaint::FilterLevel)fFilterLevel);
+    return SkTreatAsSprite(fInvMatrix, fBitmap->width(), fBitmap->height(), bits);
+}
+
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     SkASSERT(fOrigBitmap.width() && fOrigBitmap.height());
+    SkASSERT(NULL == fScaledCacheID);
 
-    fBitmap = NULL;
     fInvMatrix = inv;
     fFilterLevel = paint.getFilterLevel();
+    fBitmap = &fOrigBitmap;
 
-    SkASSERT(NULL == fScaledCacheID);
+    bool trivialMX = this->isInverseTrivial();
+    if (trivialMX) {
+        fFilterLevel = SkPaint::kNone_FilterLevel;
+    }
+
+    // Reset to null for possiblyScaleImage()
+    fBitmap = NULL;
 
     // 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.
     if (!this->possiblyScaleImage()) {
         if (!this->lockBaseBitmap()) {
             return false;
         }
     }
     // The above logic should have always assigned fBitmap, but in case it
     // didn't, we check for that now...
     // TODO(dominikg): Ask humper@ if we can just use an SkASSERT(fBitmap)?
     if (NULL == fBitmap) {
         return false;
     }
 
     // If we are "still" kMedium_FilterLevel, then the request was not fulfilled by possiblyScale,
     // so we downgrade to kLow (so the rest of the sniffing code can assume that)
     if (SkPaint::kMedium_FilterLevel == fFilterLevel) {
         fFilterLevel = SkPaint::kLow_FilterLevel;
     }
 
-    bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
+    trivialMX = this->isInverseTrivial();
+    if (trivialMX) {
+        fFilterLevel = SkPaint::kNone_FilterLevel;
+    }
+
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
-    if (!(clampClamp || trivialMatrix)) {
+    if (!(clampClamp || trivialMX)) {
         fInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
     }
 
     // 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.
 
     // This code will only execute if the matrix has some scale component;
     // if it's already pure translate then we won't do this inversion.
 
-    if (matrix_only_scale_translate(fInvMatrix)) {
+//    if (matrix_only_scale_translate(fInvMatrix)) {
+    if (trivialMX) {
         SkMatrix forward;
         if (fInvMatrix.invert(&forward)) {
             if (clampClamp ? just_trans_clamp(forward, *fBitmap)
                             : just_trans_general(forward)) {
                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
                 fInvMatrix.setTranslate(tx, ty);
             }
         }
     }
 
+    if (trivialMX && (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask)) {
+//        SkDebugf("sfsd\n");
+    }
+    
     fInvProc        = fInvMatrix.getMapXYProc();
     fInvType        = fInvMatrix.getType();
     fInvSx          = SkScalarToFixed(fInvMatrix.getScaleX());
     fInvSxFractionalInt = SkScalarToFractionalInt(fInvMatrix.getScaleX());
     fInvKy          = SkScalarToFixed(fInvMatrix.getSkewY());
     fInvKyFractionalInt = SkScalarToFractionalInt(fInvMatrix.getSkewY());
 
     fAlphaScale = SkAlpha255To256(paint.getAlpha());
 
     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 (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.
 
         if (!this->setBitmapFilterProcs()) {
             fFilterLevel = SkPaint::kLow_FilterLevel;
         }
     }
 
-    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())) {
-            fFilterLevel = SkPaint::kNone_FilterLevel;
-        }
-    }
-
     // At this point, we know exactly what kind of sampling the per-scanline
     // shader will perform.
 
-    fMatrixProc = this->chooseMatrixProc(trivialMatrix);
+    fMatrixProc = this->chooseMatrixProc(trivialMX);
     // TODO(dominikg): SkASSERT(fMatrixProc) instead? chooseMatrixProc never returns NULL.
     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 procs above and can skip all this.
@@ skipping 542 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }