Production quality fast image up/downsampler

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"
 
 #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);
@@ skipping 68 matching lines @@
 
 // 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.
 
 void SkBitmapProcState::possiblyScaleImage() {
 
     if (fFilterQuality != kHQ_BitmapFilter) {
         return;
     }
+    
+    // see if our platform has any specialized convolution code.
+    
+    
+    // Set up a pointer to a local (instead of storing the structure in the
+    // proc state) to avoid introducing a header dependency; this makes 
+    // recompiles a lot less painful.
+    
+    SkConvolutionProcs simd;
+    fConvolutionProcs = &simd;
+    
+    fConvolutionProcs->fExtraHorizontalReads = 0;
+    fConvolutionProcs->fConvolveVertically = NULL;
+    fConvolutionProcs->fConvolve4RowsHorizontally = NULL;
+    fConvolutionProcs->fConvolveHorizontally = NULL;
+    fConvolutionProcs->fApplySIMDPadding = NULL;
+    
+    this->platformConvolutionProcs();
 
-    // STEP 1: UPSAMPLE?
+    // STEP 1: Highest quality direct scale?
 
-    // Check to see if the transformation matrix is scaling up, and if
-    // the matrix is simple, and if we're doing high quality scaling.
-    // If so, do the bitmap scale here and remove the scaling component from the matrix.
+    // 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 scaling component from the matrix.
 
-    if (fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
-        (fInvMatrix.getScaleX() < 1 || fInvMatrix.getScaleY() < 1) &&
+    if (fFilterQuality == kHQ_BitmapFilter &&
+        fInvMatrix.getType() <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask) &&
         fOrigBitmap.config() == SkBitmap::kARGB_8888_Config) {
+            
+        int dest_width  = SkScalarCeilToInt(fOrigBitmap.width() / fInvMatrix.getScaleX());
+        int dest_height = SkScalarCeilToInt(fOrigBitmap.height() / fInvMatrix.getScaleY());
+        
+        // All the criteria are met; let's make a new bitmap.
 
-        // All the criteria are met; let's make a new bitmap.
-        fScaledBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                                (int)(fOrigBitmap.width() / fInvMatrix.getScaleX()),
-                                (int)(fOrigBitmap.height() / fInvMatrix.getScaleY()));
-        fScaledBitmap.allocPixels();
-        fOrigBitmap.scale(&fScaledBitmap);
+        fScaledBitmap = SkBitmapScaler::Resize( fOrigBitmap, SkBitmapScaler::RESIZE_BEST,
+                                                dest_width, dest_height, fConvolutionProcs );
+            
+        fScaledBitmap.lockPixels();
+            
         fBitmap = &fScaledBitmap;
 
         // set the inv matrix type to translate-only;
 
         fInvMatrix.setTranslate( 1/fInvMatrix.getScaleX() * fInvMatrix.getTranslateX(),
                                  1/fInvMatrix.getScaleY() * fInvMatrix.getTranslateY() );
 
         // no need for any further filtering; we just did it!
 
         fFilterQuality = kNone_BitmapFilter;
 
         return;
     }
 
-    if (!fOrigBitmap.hasMipMap()) {
+    if (!fOrigBitmap.hasMipMap() && fFilterQuality != kNone_BitmapFilter) {
 
-        // STEP 2: DOWNSAMPLE
+        // STEP 2: MIPMAP DOWNSAMPLE?
 
         // Check to see if the transformation matrix is scaling *down*.
         // If so, automatically build mipmaps.
 
         SkPoint v1, v2;
 
         // conservatively estimate if the matrix is scaling down by seeing
         // what its upper left 2x2 portion does to two unit vectors.
 
         v1.fX = fInvMatrix.getScaleX();
@@ skipping 702 matching lines @@
     } else {
         size >>= 2;
     }
 
     if (fFilterQuality != kNone_BitmapFilter) {
         size >>= 1;
     }
 
     return size;
 }