SkBitmapProcState.h revision 9c96d4b5ffdbf8c82f55b2058a2fea7225fe11d6 
1
2/*
3 * Copyright 2007 The Android Open Source Project
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#ifndef SkBitmapProcState_DEFINED
11#define SkBitmapProcState_DEFINED
12
13#include "SkBitmap.h"
14#include "SkBitmapFilter.h"
15#include "SkMatrix.h"
16
17#define FractionalInt_IS_64BIT
18
19#ifdef FractionalInt_IS_64BIT
20    typedef SkFixed48    SkFractionalInt;
21    #define SkScalarToFractionalInt(x)  SkScalarToFixed48(x)
22    #define SkFractionalIntToFixed(x)   SkFixed48ToFixed(x)
23    #define SkFixedToFractionalInt(x)   SkFixedToFixed48(x)
24    #define SkFractionalIntToInt(x)     SkFixed48ToInt(x)
25#else
26    typedef SkFixed    SkFractionalInt;
27    #define SkScalarToFractionalInt(x)  SkScalarToFixed(x)
28    #define SkFractionalIntToFixed(x)   (x)
29    #define SkFixedToFractionalInt(x)   (x)
30    #define SkFractionalIntToInt(x)     ((x) >> 16)
31#endif
32
33class SkPaint;
34
35struct SkBitmapProcState {
36
37    SkBitmapProcState(): fBitmapFilter(NULL) {}
38    ~SkBitmapProcState() {
39        SkDELETE(fBitmapFilter);
40    }
41
42    typedef void (*ShaderProc32)(const SkBitmapProcState&, int x, int y,
43                                 SkPMColor[], int count);
44
45    typedef void (*ShaderProc16)(const SkBitmapProcState&, int x, int y,
46                                 uint16_t[], int count);
47
48    typedef void (*MatrixProc)(const SkBitmapProcState&,
49                               uint32_t bitmapXY[],
50                               int count,
51                               int x, int y);
52
53    typedef void (*SampleProc32)(const SkBitmapProcState&,
54                                 const uint32_t[],
55                                 int count,
56                                 SkPMColor colors[]);
57
58    typedef void (*SampleProc16)(const SkBitmapProcState&,
59                                 const uint32_t[],
60                                 int count,
61                                 uint16_t colors[]);
62
63    typedef U16CPU (*FixedTileProc)(SkFixed);   // returns 0..0xFFFF
64    typedef U16CPU (*FixedTileLowBitsProc)(SkFixed, int);   // returns 0..0xF
65    typedef U16CPU (*IntTileProc)(int value, int count);   // returns 0..count-1
66
67    const SkBitmap*     fBitmap;            // chooseProcs - orig or scaled
68    SkMatrix            fInvMatrix;         // chooseProcs
69    SkMatrix::MapXYProc fInvProc;           // chooseProcs
70
71    SkFractionalInt     fInvSxFractionalInt;
72    SkFractionalInt     fInvKyFractionalInt;
73
74    FixedTileProc       fTileProcX;         // chooseProcs
75    FixedTileProc       fTileProcY;         // chooseProcs
76    FixedTileLowBitsProc fTileLowBitsProcX; // chooseProcs
77    FixedTileLowBitsProc fTileLowBitsProcY; // chooseProcs
78    IntTileProc         fIntTileProcY;      // chooseProcs
79    SkFixed             fFilterOneX;
80    SkFixed             fFilterOneY;
81
82    SkPMColor           fPaintPMColor;      // chooseProcs - A8 config
83    SkFixed             fInvSx;             // chooseProcs
84    SkFixed             fInvKy;             // chooseProcs
85    uint16_t            fAlphaScale;        // chooseProcs
86    uint8_t             fInvType;           // chooseProcs
87    uint8_t             fTileModeX;         // CONSTRUCTOR
88    uint8_t             fTileModeY;         // CONSTRUCTOR
89
90    enum {
91        kNone_BitmapFilter,
92        kBilerp_BitmapFilter,
93        kHQ_BitmapFilter
94    } fFilterQuality;          // chooseProcs
95
96    /** The shader will let us know when we can release some of our resources
97      * like scaled bitmaps.
98      */
99
100    void endContext();
101
102    /** Platforms implement this, and can optionally overwrite only the
103        following fields:
104
105        fShaderProc32
106        fShaderProc16
107        fMatrixProc
108        fSampleProc32
109        fSampleProc32
110
111        They will already have valid function pointers, so a platform that does
112        not have an accelerated version can just leave that field as is. A valid
113        implementation can do nothing (see SkBitmapProcState_opts_none.cpp)
114     */
115    void platformProcs();
116
117
118    /** Given the byte size of the index buffer to be passed to the matrix proc,
119        return the maximum number of resulting pixels that can be computed
120        (i.e. the number of SkPMColor values to be written by the sample proc).
121        This routine takes into account that filtering and scale-vs-affine
122        affect the amount of buffer space needed.
123
124        Only valid to call after chooseProcs (setContext) has been called. It is
125        safe to call this inside the shader's shadeSpan() method.
126     */
127    int maxCountForBufferSize(size_t bufferSize) const;
128
129    // If a shader proc is present, then the corresponding matrix/sample procs
130    // are ignored
131    ShaderProc32 getShaderProc32() const { return fShaderProc32; }
132    ShaderProc16 getShaderProc16() const { return fShaderProc16; }
133
134    SkBitmapFilter* getBitmapFilter() const { return fBitmapFilter; }
135
136#ifdef SK_DEBUG
137    MatrixProc getMatrixProc() const;
138#else
139    MatrixProc getMatrixProc() const { return fMatrixProc; }
140#endif
141    SampleProc32 getSampleProc32() const { return fSampleProc32; }
142    SampleProc16 getSampleProc16() const { return fSampleProc16; }
143
144private:
145    friend class SkBitmapProcShader;
146
147    ShaderProc32        fShaderProc32;      // chooseProcs
148    ShaderProc16        fShaderProc16;      // chooseProcs
149    // These are used if the shaderproc is NULL
150    MatrixProc          fMatrixProc;        // chooseProcs
151    SampleProc32        fSampleProc32;      // chooseProcs
152    SampleProc16        fSampleProc16;      // chooseProcs
153
154    SkBitmap            fOrigBitmap;        // CONSTRUCTOR
155    SkBitmap            fScaledBitmap;      // chooseProcs
156
157    MatrixProc chooseMatrixProc(bool trivial_matrix);
158    bool chooseProcs(const SkMatrix& inv, const SkPaint&);
159    ShaderProc32 chooseShaderProc32();
160
161    void possiblyScaleImage();
162
163    SkBitmapFilter *fBitmapFilter;
164
165    ShaderProc32 chooseBitmapFilterProc();
166
167    // Return false if we failed to setup for fast translate (e.g. overflow)
168    bool setupForTranslate();
169
170#ifdef SK_DEBUG
171    static void DebugMatrixProc(const SkBitmapProcState&,
172                                uint32_t[], int count, int x, int y);
173#endif
174};
175
176/*  Macros for packing and unpacking pairs of 16bit values in a 32bit uint.
177    Used to allow access to a stream of uint16_t either one at a time, or
178    2 at a time by unpacking a uint32_t
179 */
180#ifdef SK_CPU_BENDIAN
181    #define PACK_TWO_SHORTS(pri, sec) ((pri) << 16 | (sec))
182    #define UNPACK_PRIMARY_SHORT(packed)    ((uint32_t)(packed) >> 16)
183    #define UNPACK_SECONDARY_SHORT(packed)  ((packed) & 0xFFFF)
184#else
185    #define PACK_TWO_SHORTS(pri, sec) ((pri) | ((sec) << 16))
186    #define UNPACK_PRIMARY_SHORT(packed)    ((packed) & 0xFFFF)
187    #define UNPACK_SECONDARY_SHORT(packed)  ((uint32_t)(packed) >> 16)
188#endif
189
190#ifdef SK_DEBUG
191    static inline uint32_t pack_two_shorts(U16CPU pri, U16CPU sec) {
192        SkASSERT((uint16_t)pri == pri);
193        SkASSERT((uint16_t)sec == sec);
194        return PACK_TWO_SHORTS(pri, sec);
195    }
196#else
197    #define pack_two_shorts(pri, sec)   PACK_TWO_SHORTS(pri, sec)
198#endif
199
200// These functions are generated via macros, but are exposed here so that
201// platformProcs may test for them by name.
202void S32_opaque_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[],
203                              int count, SkPMColor colors[]);
204void S32_alpha_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[],
205                             int count, SkPMColor colors[]);
206void S32_opaque_D32_filter_DXDY(const SkBitmapProcState& s,
207                           const uint32_t xy[], int count, SkPMColor colors[]);
208void S32_alpha_D32_filter_DXDY(const SkBitmapProcState& s,
209                           const uint32_t xy[], int count, SkPMColor colors[]);
210void ClampX_ClampY_filter_scale(const SkBitmapProcState& s, uint32_t xy[],
211                                int count, int x, int y);
212void ClampX_ClampY_nofilter_scale(const SkBitmapProcState& s, uint32_t xy[],
213                                  int count, int x, int y);
214void ClampX_ClampY_filter_affine(const SkBitmapProcState& s,
215                                 uint32_t xy[], int count, int x, int y);
216void ClampX_ClampY_nofilter_affine(const SkBitmapProcState& s,
217                                   uint32_t xy[], int count, int x, int y);
218void S32_D16_filter_DX(const SkBitmapProcState& s,
219                                   const uint32_t* xy, int count, uint16_t* colors);
220
221void highQualityFilter_ScaleOnly(const SkBitmapProcState &s, int x, int y,
222                             SkPMColor *SK_RESTRICT colors, int count);
223void highQualityFilter(const SkBitmapProcState &s, int x, int y,
224                   SkPMColor *SK_RESTRICT colors, int count);
225
226
227#endif
228