Production quality fast image up/downsampler

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 13 matching lines @@
     #define SkFractionalIntToInt(x)     SkFixed48ToInt(x)
 #else
     typedef SkFixed    SkFractionalInt;
     #define SkScalarToFractionalInt(x)  SkScalarToFixed(x)
     #define SkFractionalIntToFixed(x)   (x)
     #define SkFixedToFractionalInt(x)   (x)
     #define SkFractionalIntToInt(x)     ((x) >> 16)
 #endif
 
 class SkPaint;
+class SkConvolutionProcs;
 
 struct SkBitmapProcState {
 
     SkBitmapProcState(): fBitmapFilter(NULL) {}
     ~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 scaled
     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;
+    
+    SkConvolutionProcs* fConvolutionProcs;         // possiblyScaleImage
 
     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
 
     enum {
@@ skipping 15 matching lines @@
         fShaderProc16
         fMatrixProc
         fSampleProc32
         fSampleProc32
 
         They will already have valid function pointers, so a platform that does
         not have an accelerated version can just leave that field as is. A valid
         implementation can do nothing (see SkBitmapProcState_opts_none.cpp)
      */
     void platformProcs();
-
+    
+    /** Platforms can also optionally overwrite the convolution functions
+        if we have SIMD versions of them.
+      */
+      
+    void platformConvolutionProcs();
 
     /** Given the byte size of the index buffer to be passed to the matrix proc,
         return the maximum number of resulting pixels that can be computed
         (i.e. the number of SkPMColor values to be written by the sample proc).
         This routine takes into account that filtering and scale-vs-affine
         affect the amount of buffer space needed.
 
         Only valid to call after chooseProcs (setContext) has been called. It is
         safe to call this inside the shader's shadeSpan() method.
      */
@@ skipping 84 matching lines @@
                                 int count, int x, int y);
 void ClampX_ClampY_nofilter_scale(const SkBitmapProcState& s, uint32_t xy[],
                                   int count, int x, int y);
 void ClampX_ClampY_filter_affine(const SkBitmapProcState& s,
                                  uint32_t xy[], int count, int x, int y);
 void ClampX_ClampY_nofilter_affine(const SkBitmapProcState& s,
                                    uint32_t xy[], int count, int x, int y);
 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