Working plumb of image scaling:

src/core/SkBitmapProcState.h

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkBitmapProcState_DEFINED
@@ skipping 15 matching lines @@
     typedef SkFixed    SkFractionalInt;
     #define SkScalarToFractionalInt(x)  SkScalarToFixed(x)
     #define SkFractionalIntToFixed(x)   (x)
     #define SkFixedToFractionalInt(x)   (x)
     #define SkFractionalIntToInt(x)     ((x) >> 16)
 #endif
 
 class SkPaint;
 
 struct SkBitmapProcState {
-
+    
     SkBitmapProcState(): fBitmapFilter(NULL) {}

[robertphillips, 2013/07/12 19:42:31]

We don't need:

~SkBitmapProcState() {
    this->endContext()
}

?

[humper, 2013/07/12 21:12:03]

Cleaned up.  It's not right to call endcontext, but we should make sure that we
don't leak if, for some reason, endContext wasn't called.

-    ~SkBitmapProcState() {
-        SkDELETE(fBitmapFilter);
-    }
 
     typedef void (*ShaderProc32)(const SkBitmapProcState&, int x, int y,
                                  SkPMColor[], int count);
 
     typedef void (*ShaderProc16)(const SkBitmapProcState&, int x, int y,
                                  uint16_t[], int count);
 
     typedef void (*MatrixProc)(const SkBitmapProcState&,
                                uint32_t bitmapXY[],
                                int count,
                                int x, int y);
 
     typedef void (*SampleProc32)(const SkBitmapProcState&,
                                  const uint32_t[],
                                  int count,
                                  SkPMColor colors[]);
 
     typedef void (*SampleProc16)(const SkBitmapProcState&,
                                  const uint32_t[],
                                  int count,
                                  uint16_t colors[]);
 
     typedef U16CPU (*FixedTileProc)(SkFixed);   // returns 0..0xFFFF
     typedef U16CPU (*FixedTileLowBitsProc)(SkFixed, int);   // returns 0..0xF
     typedef U16CPU (*IntTileProc)(int value, int count);   // returns 0..count-1
 
     const SkBitmap*     fBitmap;            // chooseProcs - orig or mip

[reed1, 2013/07/12 18:33:24]

orig or scaled

[humper, 2013/07/12 21:12:03]

Done.

-    const SkMatrix*     fInvMatrix;         // chooseProcs
+    SkMatrix            fInvMatrix;         // chooseProcs
     SkMatrix::MapXYProc fInvProc;           // chooseProcs
 
     SkFractionalInt     fInvSxFractionalInt;
     SkFractionalInt     fInvKyFractionalInt;
 
     FixedTileProc       fTileProcX;         // chooseProcs
     FixedTileProc       fTileProcY;         // chooseProcs
     FixedTileLowBitsProc fTileLowBitsProcX; // chooseProcs
     FixedTileLowBitsProc fTileLowBitsProcY; // chooseProcs
     IntTileProc         fIntTileProcY;      // chooseProcs
     SkFixed             fFilterOneX;
     SkFixed             fFilterOneY;
 
     SkPMColor           fPaintPMColor;      // chooseProcs - A8 config
     SkFixed             fInvSx;             // chooseProcs
     SkFixed             fInvKy;             // chooseProcs
     uint16_t            fAlphaScale;        // chooseProcs
     uint8_t             fInvType;           // chooseProcs
     uint8_t             fTileModeX;         // CONSTRUCTOR
     uint8_t             fTileModeY;         // CONSTRUCTOR
-    SkBool8             fDoFilter;          // chooseProcs
+    
+    enum { 
+        kNone_BitmapFilter, 
+        kBilerp_BitmapFilter, 
+        kHQ_BitmapFilter
+    } fFilterQuality;          // chooseProcs
+
+    /** The shader will let us know when we can release some of our resources
+      * like scaled bitmaps.
+      */
+
+    void endContext();
 
     /** Platforms implement this, and can optionally overwrite only the
         following fields:
 
         fShaderProc32
         fShaderProc16
         fMatrixProc
         fSampleProc32
         fSampleProc32
 
@@ skipping 33 matching lines @@
 private:
     friend class SkBitmapProcShader;
 
     ShaderProc32        fShaderProc32;      // chooseProcs
     ShaderProc16        fShaderProc16;      // chooseProcs
     // These are used if the shaderproc is NULL
     MatrixProc          fMatrixProc;        // chooseProcs
     SampleProc32        fSampleProc32;      // chooseProcs
     SampleProc16        fSampleProc16;      // chooseProcs
 
-    SkMatrix            fUnitInvMatrix;     // chooseProcs
     SkBitmap            fOrigBitmap;        // CONSTRUCTOR
-    SkBitmap            fMipBitmap;
+    SkBitmap            fScaledBitmap;      // chooseProcs
 
     MatrixProc chooseMatrixProc(bool trivial_matrix);
     bool chooseProcs(const SkMatrix& inv, const SkPaint&);
     ShaderProc32 chooseShaderProc32();
+    
+    void possiblyScaleImage();
 
-    void buildFilterCoefficients(SkFixed dst[4], float t) const;
     SkBitmapFilter *fBitmapFilter;
 
-    ShaderProc32 chooseBitmapFilterProc(const SkPaint &paint);
+    ShaderProc32 chooseBitmapFilterProc();
 
     // Return false if we failed to setup for fast translate (e.g. overflow)
     bool setupForTranslate();
 
 #ifdef SK_DEBUG
     static void DebugMatrixProc(const SkBitmapProcState&,
                                 uint32_t[], int count, int x, int y);
 #endif
 };
 
@@ skipping 42 matching lines @@
 void S32_D16_filter_DX(const SkBitmapProcState& s,
                                    const uint32_t* xy, int count, uint16_t* colors);
 
 void highQualityFilter_ScaleOnly(const SkBitmapProcState &s, int x, int y,
                              SkPMColor *SK_RESTRICT colors, int count);
 void highQualityFilter(const SkBitmapProcState &s, int x, int y,
                    SkPMColor *SK_RESTRICT colors, int count);
 
 
 #endif