reorg filter quality cascade

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 "SkBitmapCache.h"
 #include "SkBitmapProcState.h"
 #include "SkColorPriv.h"
@@ skipping 260 matching lines @@
             return true;
         } else {
             // failed to extract, so release the mipmap
             fCurrMip.reset(NULL);
         }
     }
 
     return false;
 }
 
+/*
+ *  Extract the "best" scale factors from a matrix.
+ */
+static bool extract_scale(const SkMatrix& matrix, SkVector* scale) {
+    SkASSERT(!matrix.hasPerspective());
+    SkScalar sx = SkPoint::Length(matrix[SkMatrix::kMScaleX], matrix[SkMatrix::kMSkewY]);
+    SkScalar sy = SkPoint::Length(matrix[SkMatrix::kMSkewX],  matrix[SkMatrix::kMScaleY]);
+    if (!SkScalarIsFinite(sx) || !SkScalarIsFinite(sy) ||
+        SkScalarNearlyZero(sx) || SkScalarNearlyZero(sy))
+    {
+        return false;
+    }
+    scale->set(sx, sy);
+    return true;
+}
+
+/*

[robertphillips, 2015/01/16 19:45:00]

implemented

[reed1, 2015/01/16 19:48:20]

Done.

+ *  High quality is implement by performing up-right scale-only filtering and then
+ *  using bilerp for any remaining transformations.
+ */
+void SkBitmapProcState::processHQRequest() {
+    SkASSERT(SkPaint::kHigh_FilterLevel == fFilterLevel);
+
+    // Our default return state is to downgrade the request to Medium, w/ or w/o setting fBitmap
+    // to a valid bitmap. If we succeed, we will set this to Low instead.
+    fFilterLevel = SkPaint::kMedium_FilterLevel;
+
+    if (kN32_SkColorType != fOrigBitmap.colorType() || !cache_size_okay(fOrigBitmap, fInvMatrix) ||
+        fInvMatrix.hasPerspective())
+    {
+        return; // can't handle the reqeust
+    }
+
+    SkScalar invScaleX = fInvMatrix.getScaleX();
+    SkScalar invScaleY = fInvMatrix.getScaleY();
+    if (fInvMatrix.getType() & SkMatrix::kAffine_Mask) {
+        SkVector scale;
+        if (!extract_scale(fInvMatrix, &scale)) {
+            return; // can't find suitable scale factors
+        }
+        invScaleX = scale.x();
+        invScaleY = scale.y();
+    }
+    if (SkScalarNearlyEqual(invScaleX, 1) && SkScalarNearlyEqual(invScaleY, 1)) {
+        return; // no need for HQ
+    }
+
+    SkScalar trueDestWidth  = fOrigBitmap.width() / invScaleX;
+    SkScalar trueDestHeight = fOrigBitmap.height() / invScaleY;
+    SkScalar roundedDestWidth = SkScalarRoundToScalar(trueDestWidth);
+    SkScalar roundedDestHeight = SkScalarRoundToScalar(trueDestHeight);
+
+    if (!SkBitmapCache::Find(fOrigBitmap, roundedDestWidth, roundedDestHeight, &fScaledBitmap)) {
+        if (!SkBitmapScaler::Resize(&fScaledBitmap,
+                                    fOrigBitmap,
+                                    SkBitmapScaler::RESIZE_BEST,
+                                    roundedDestWidth,
+                                    roundedDestHeight,
+                                    SkResourceCache::GetAllocator())) {
+            return; // we failed to create fScaledBitmap
+        }
+
+        SkASSERT(fScaledBitmap.getPixels());
+        fScaledBitmap.setImmutable();
+        SkBitmapCache::Add(fOrigBitmap, roundedDestWidth, roundedDestHeight, fScaledBitmap);
+    }
+
+    SkASSERT(fScaledBitmap.getPixels());
+    fBitmap = &fScaledBitmap;
+
+    fInvMatrix.postScale(roundedDestWidth / fOrigBitmap.width(),
+                         roundedDestHeight / fOrigBitmap.height());
+    fFilterLevel = SkPaint::kLow_FilterLevel;
+}
+
+/*
+ *  Modulo internal errors, this should always succeed *if* the matrix is downscaling
+ *  (in this case, we have the inverse, so it succeeds if fInvMatrix is upscaling)
+ */
+void SkBitmapProcState::processMediumRequest() {
+    SkASSERT(SkPaint::kMedium_FilterLevel == fFilterLevel);
+
+    // Our default return state is to downgrade the request to Low, w/ or w/o setting fBitmap
+    // to a valid bitmap.
+    fFilterLevel = SkPaint::kLow_FilterLevel;
+
+    SkScalar invScaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
+
+    if (invScaleSqd > SK_Scalar1) {
+        fCurrMip.reset(SkMipMapCache::FindAndRef(fOrigBitmap));
+        if (NULL == fCurrMip.get()) {
+            fCurrMip.reset(SkMipMapCache::AddAndRef(fOrigBitmap));
+            if (NULL == fCurrMip.get()) {
+                return;
+            }
+        }
+        // diagnostic for a crasher...
+        if (NULL == fCurrMip->data()) {
+            sk_throw();
+        }
+
+        SkScalar levelScale = SkScalarInvert(SkScalarSqrt(invScaleSqd));
+        SkMipMap::Level level;
+        if (fCurrMip->extractLevel(levelScale, &level)) {
+            SkScalar invScaleFixup = level.fScale;
+            fInvMatrix.postScale(invScaleFixup, invScaleFixup);
+
+            const SkImageInfo info = fOrigBitmap.info().makeWH(level.fWidth, level.fHeight);
+            // todo: if we could wrap the fCurrMip in a pixelref, then we could just install
+            //       that here, and not need to explicitly track it ourselves.
+            fScaledBitmap.installPixels(info, level.fPixels, level.fRowBytes);
+            fBitmap = &fScaledBitmap;
+        } else {
+            // failed to extract, so release the mipmap
+            fCurrMip.reset(NULL);
+        }
+    }
+}
+
 static bool get_locked_pixels(const SkBitmap& src, int pow2, SkBitmap* dst) {
     SkPixelRef* pr = src.pixelRef();
     if (pr && pr->decodeInto(pow2, dst)) {
         return true;
     }
 
     /*
      *  If decodeInto() fails, it is possibe that we have an old subclass that
      *  does not, or cannot, implement that. In that case we fall back to the
      *  older protocol of having the pixelRef handle the caching for us.
@@ skipping 46 matching lines @@
     }
     if (kIndex_8_SkColorType == bm.colorType()) {
         SkAutoLockPixels alp(bm); // but we need to call it before getColorTable() is safe.
         if (!bm.getColorTable()) {
             return false;
         }
     }
     return true;
 }
 
+/*
+ *  Analyze filter-quality and matrix, and decide how to implement that.
+ *
+ *  In general, we cascade down the request level [ High ... None ]
+ *  - for a given level, if we can fullfil it, fine, else
+ *    - else we downgrade to the next lower level and try again.

[robertphillips, 2015/01/16 19:44:59]

fulfill

+ *  We can always fullfil requests for Low and None

[robertphillips, 2015/01/16 19:45:00]

and given ?

[reed1, 2015/01/16 19:48:20]

Done.

+ *  - sometimes we will "ignore" Low and given none, but this is likely a legacy perf hack
+ *    and may be removed.
+ */
 bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     if (!valid_for_drawing(fOrigBitmap)) {
         return false;
     }
 
     fBitmap = NULL;
     fInvMatrix = inv;
     fFilterLevel = paint.getFilterLevel();
 
+#ifdef SK_SUPPORT_LEGACY_HQ_SCALING
     // 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;
     }
+#else
+    if (SkPaint::kHigh_FilterLevel == fFilterLevel) {
+        this->processHQRequest();
+    }
+    SkASSERT(fFilterLevel < SkPaint::kHigh_FilterLevel);
+
+    if (SkPaint::kMedium_FilterLevel == fFilterLevel) {
+        this->processMediumRequest();
+    }
+    SkASSERT(fFilterLevel < SkPaint::kMedium_FilterLevel);
+
+    if (NULL == fBitmap) {
+        if (!this->lockBaseBitmap()) {
+            return false;
+        }
+    }
+    SkASSERT(fBitmap);
+#endif
 
     bool trivialMatrix = (fInvMatrix.getType() & ~SkMatrix::kTranslate_Mask) == 0;
     bool clampClamp = SkShader::kClamp_TileMode == fTileModeX &&
                       SkShader::kClamp_TileMode == fTileModeY;
 
     // Most of the scanline procs deal with "unit" texture coordinates, as this
     // makes it easy to perform tiling modes (repeat = (x & 0xFFFF)). To generate
     // those, we divide the matrix by its dimensions here.
     //
     // We don't do this if we're either trivial (can ignore the matrix) or clamping
     // in both X and Y since clamping to width,height is just as easy as to 0xFFFF.
 
     if (!(clampClamp || trivialMatrix)) {
         fInvMatrix.postIDiv(fBitmap->width(), fBitmap->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)) {
         SkMatrix forward;
         if (fInvMatrix.invert(&forward)) {
             if (clampClamp ? just_trans_clamp(forward, *fBitmap)
-                            : just_trans_general(forward)) {
+                           : just_trans_general(forward)) {
                 SkScalar tx = -SkScalarRoundToScalar(forward.getTranslateX());
                 SkScalar ty = -SkScalarRoundToScalar(forward.getTranslateY());
                 fInvMatrix.setTranslate(tx, ty);
             }
         }
     }
 
     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())) {
+            !valid_for_filtering(fBitmap->width() | fBitmap->height()))
+        {
             fFilterLevel = SkPaint::kNone_FilterLevel;
         }
     }
 
     return this->chooseScanlineProcs(trivialMatrix, clampClamp, paint);
 }
 
 bool SkBitmapProcState::chooseScanlineProcs(bool trivialMatrix, bool clampClamp,
                                             const SkPaint& paint) {
     fMatrixProc = this->chooseMatrixProc(trivialMatrix);
@@ skipping 620 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }