remove dead code after HQ change

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 106 matching lines @@
     if (0 == maximumAllocation) {
         return true;
     }
     // float matrixScaleFactor = 1.0 / (invMat.scaleX * invMat.scaleY);
     // return ((origBitmapSize * matrixScaleFactor) < maximumAllocationSize);
     // Skip the division step:
     return bm.info().getSafeSize(bm.info().minRowBytes())
         < (maximumAllocation * invMat.getScaleX() * invMat.getScaleY());
 }
 
-// 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.
-
-bool SkBitmapProcState::possiblyScaleImage() {
-    SkASSERT(NULL == fBitmap);
-
-    if (fFilterLevel <= SkPaint::kLow_FilterLevel) {
-        return false;
-    }
-    // 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 (non-fractional) scaling component from the matrix.
-
-    SkScalar invScaleX = fInvMatrix.getScaleX();
-    SkScalar invScaleY = fInvMatrix.getScaleY();
-
-    float trueDestWidth  = fOrigBitmap.width() / invScaleX;
-    float trueDestHeight = fOrigBitmap.height() / invScaleY;
-
-    float roundedDestWidth = SkScalarRoundToScalar(trueDestWidth);
-    float roundedDestHeight = SkScalarRoundToScalar(trueDestHeight);
-
-    if (SkPaint::kHigh_FilterLevel == fFilterLevel &&
-        fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
-        kN32_SkColorType == fOrigBitmap.colorType() &&
-        cache_size_okay(fOrigBitmap, fInvMatrix)) {
-
-        if (SkScalarNearlyEqual(invScaleX,1.0f) &&
-            SkScalarNearlyEqual(invScaleY,1.0f)) {
-            // short-circuit identity scaling; the output is supposed to
-            // be the same as the input, so we might as well go fast.
-
-            // Note(humper): We could also probably do this if the scales
-            // are close to -1 as well, since the flip doesn't require
-            // any fancy re-sampling...
-
-            // Set our filter level to low -- the only post-filtering this
-            // image might require is some interpolation if the translation
-            // is fractional.
-            fFilterLevel = SkPaint::kLow_FilterLevel;
-            return false;
-        }
-
-        if (!SkBitmapCache::Find(fOrigBitmap, roundedDestWidth, roundedDestHeight, &fScaledBitmap)) {
-            // All the criteria are met; let's make a new bitmap.
-
-            if (!SkBitmapScaler::Resize(&fScaledBitmap,
-                                        fOrigBitmap,
-                                        SkBitmapScaler::RESIZE_BEST,
-                                        roundedDestWidth,
-                                        roundedDestHeight,
-                                        SkResourceCache::GetAllocator())) {
-                // we failed to create fScaledBitmap, so just return and let
-                // the scanline proc handle it.
-                return false;
-
-            }
-
-            SkASSERT(fScaledBitmap.getPixels());
-            fScaledBitmap.setImmutable();
-            SkBitmapCache::Add(fOrigBitmap, roundedDestWidth, roundedDestHeight, fScaledBitmap);
-        }
-
-        SkASSERT(fScaledBitmap.getPixels());
-        fBitmap = &fScaledBitmap;
-
-        // clean up the inverse matrix by incorporating the scale we just performed.
-
-        fInvMatrix.postScale(roundedDestWidth / fOrigBitmap.width(),
-                             roundedDestHeight / fOrigBitmap.height());
-
-        // Set our filter level to low -- the only post-filtering this
-        // image might require is some interpolation if the translation
-        // is fractional or if there's any remaining scaling to be done.
-        fFilterLevel = SkPaint::kLow_FilterLevel;
-        return true;
-    }
-
-    /*
-     *  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.
-     */
-
-    SkScalar scaleSqd = effective_matrix_scale_sqrd(fInvMatrix);
-
-    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 = 4.0f;
-        const SkScalar bicubicLimitSqd = bicubicLimit * bicubicLimit;
-        if (scaleSqd < bicubicLimitSqd) {  // use bicubic scanline
-            return false;
-        }
-
-        // 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);
-
-    /**
-     *  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) {
-        fCurrMip.reset(SkMipMapCache::FindAndRef(fOrigBitmap));
-        if (NULL == fCurrMip.get()) {
-            fCurrMip.reset(SkMipMapCache::AddAndRef(fOrigBitmap));
-            if (NULL == fCurrMip.get()) {
-                return false;
-            }
-        }
-        // diagnostic for a crasher...
-        if (NULL == fCurrMip->data()) {
-            sk_throw();
-        }
-
-        SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
-        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;
-            fFilterLevel = SkPaint::kLow_FilterLevel;
-            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))
     {
@@ skipping 141 matching lines @@
             // TODO: if fScaled comes back at a different width/height than fOrig,
             // we need to update the matrix we are using to sample from this guy.
 
             SkBitmapCache::Add(fOrigBitmap, 1, 1, fScaledBitmap);
         }
     }
     fBitmap = &fScaledBitmap;
     return true;
 }
 
-SkBitmapProcState::~SkBitmapProcState() {
-    SkDELETE(fBitmapFilter);
-}
-
 static bool valid_for_drawing(const SkBitmap& bm) {
     if (0 == bm.width() || 0 == bm.height()) {
         return false;   // nothing to draw
     }
     if (NULL == bm.pixelRef()) {
         return false;   // no pixels to read
     }
     if (bm.getTexture()) {
         // we can handle texture (ugh) since lockPixels will perform a read-back
         return true;
@@ skipping 90 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 (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;
         }
     }
@@ skipping 627 matching lines @@
             fx += dx;
         }
     } else {
         for (int i = 0; i < count; ++i) {
             dst[i] = src[SkClampMax(SkFractionalIntToInt(fx), maxX)];
             fx += dx;
         }
     }
 }