add mipmaps to scaledimagecache

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 "SkMipMap.h"
 #include "SkScaledImageCache.h"
 
 #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*);
@@ skipping 60 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;
 }
 
-static bool effective_matrix_scale_sqrd(const SkMatrix& mat) {
+static SkScalar effective_matrix_scale_sqrd(const SkMatrix& mat) {
     SkPoint v1, v2;
 
     v1.fX = mat.getScaleX();
     v1.fY = mat.getSkewY();
 
     v2.fX = mat.getSkewX();
     v2.fY = mat.getScaleY();
 
     return SkMaxScalar(v1.lengthSqd(), v2.lengthSqd());
 }
@@ skipping 112 matching lines @@
     }
 
     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) {
-        if (!fOrigBitmap.hasMipMap()) {
-            fOrigBitmap.buildMipMap();
-            // build may fail, so we need to check again
+        const SkMipMap* mip = NULL;
+
+        SkASSERT(NULL == fScaledCacheID);
+        fScaledCacheID = SkScaledImageCache::FindAndLockMip(fOrigBitmap, &mip);
+        if (!fScaledCacheID) {
+            SkASSERT(NULL == mip);
+            mip = SkMipMap::Build(fOrigBitmap);
+            if (mip) {
+                fScaledCacheID = SkScaledImageCache::AddAndLockMip(fOrigBitmap,
+                                                                   mip);
+                mip->unref();   // the cache took a ref
+                SkASSERT(fScaledCacheID);
+            }
+        } else {
+            SkASSERT(mip);
         }
-        if (fOrigBitmap.hasMipMap()) {
-            int shift = fOrigBitmap.extractMipLevel(&fScaledBitmap,
-                                        SkScalarToFixed(fInvMatrix.getScaleX()),
-                                        SkScalarToFixed(fInvMatrix.getSkewY()));
-            if (shift > 0) {
-                SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
-                fInvMatrix.postScale(scale, scale);
+        
+        if (mip) {
+            SkScalar levelScale = SkScalarInvert(SkScalarSqrt(scaleSqd));
+            SkMipMap::Level level;
+            if (mip->extractLevel(levelScale, &level)) {
+                SkScalar invScaleFixup = level.fScale;
+                fInvMatrix.postScale(invScaleFixup, invScaleFixup);
+                
+                fScaledBitmap.setConfig(fOrigBitmap.config(),
+                                        level.fWidth, level.fHeight,
+                                        level.fRowBytes);
+                fScaledBitmap.setPixels(level.fPixels);
                 fBitmap = &fScaledBitmap;
             }
         }
     }
 
-    // Now that we've built the mipmaps (if applicable), we set the filter-level
-    // bilinear interpolation.
+    /*
+     *  At this point, we may or may not have built a mipmap. Regardless, we
+     *  now fall back on Low so will bilerp whatever fBitmap now points at.
+     */
     fFilterLevel = SkPaint::kLow_FilterLevel;
 }
 
 void SkBitmapProcState::endContext() {
     SkDELETE(fBitmapFilter);
     fBitmapFilter = NULL;
     fScaledBitmap.reset();
     
     if (fScaledCacheID) {
         SkScaledImageCache::Unlock(fScaledCacheID);
@@ skipping 660 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterLevel != SkPaint::kNone_FilterLevel) {
         size >>= 1;
     }
 
     return size;
 }