1/*
2 * Copyright 2007 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef SkBitmapProcState_DEFINED
9#define SkBitmapProcState_DEFINED
10
11#include "SkBitmap.h"
12#include "SkBitmapController.h"
13#include "SkBitmapProvider.h"
14#include "SkFixed.h"
15#include "SkFloatBits.h"
16#include "SkMatrixPriv.h"
17#include "SkMipMap.h"
18#include "SkPaint.h"
19#include "SkShader.h"
20#include "SkTemplates.h"
21
22typedef SkFixed3232    SkFractionalInt;
23#define SkScalarToFractionalInt(x)  SkScalarToFixed3232(x)
24#define SkFractionalIntToFixed(x)   SkFixed3232ToFixed(x)
25#define SkFixedToFractionalInt(x)   SkFixedToFixed3232(x)
26#define SkFractionalIntToInt(x)     SkFixed3232ToInt(x)
27
28class SkPaint;
29
30struct SkBitmapProcInfo {
31    SkBitmapProcInfo(const SkBitmapProvider&, SkShader::TileMode tmx, SkShader::TileMode tmy);
32    ~SkBitmapProcInfo();
33
34    const SkBitmapProvider        fProvider;
35
36    SkPixmap                      fPixmap;
37    SkMatrix                      fInvMatrix;         // This changes based on tile mode.
38    // TODO: combine fInvMatrix and fRealInvMatrix.
39    SkMatrix                      fRealInvMatrix;     // The actual inverse matrix.
40    SkColor                       fPaintColor;
41    SkShader::TileMode            fTileModeX;
42    SkShader::TileMode            fTileModeY;
43    SkFilterQuality               fFilterQuality;
44    SkMatrix::TypeMask            fInvType;
45
46    bool init(const SkMatrix& inverse, const SkPaint&);
47
48private:
49    enum {
50        kBMStateSize = 136  // found by inspection. if too small, we will call new/delete
51    };
52    SkAlignedSStorage<kBMStateSize> fBMStateStorage;
53    SkBitmapController::State* fBMState;
54};
55
56struct SkBitmapProcState : public SkBitmapProcInfo {
57    SkBitmapProcState(const SkBitmapProvider& prov, SkShader::TileMode tmx, SkShader::TileMode tmy)
58        : SkBitmapProcInfo(prov, tmx, tmy) {}
59
60    bool setup(const SkMatrix& inv, const SkPaint& paint) {
61        return this->init(inv, paint) && this->chooseProcs();
62    }
63
64    typedef void (*ShaderProc32)(const void* ctx, int x, int y, SkPMColor[], int count);
65
66    typedef void (*ShaderProc16)(const void* ctx, int x, int y, uint16_t[], int count);
67
68    typedef void (*MatrixProc)(const SkBitmapProcState&,
69                               uint32_t bitmapXY[],
70                               int count,
71                               int x, int y);
72
73    typedef void (*SampleProc32)(const SkBitmapProcState&,
74                                 const uint32_t[],
75                                 int count,
76                                 SkPMColor colors[]);
77
78    typedef U16CPU (*FixedTileProc)(SkFixed);   // returns 0..0xFFFF
79    typedef U16CPU (*IntTileProc)(int value, int count);   // returns 0..count-1
80
81    SkMatrixPriv::MapXYProc fInvProc;           // chooseProcs
82    SkFractionalInt     fInvSxFractionalInt;
83    SkFractionalInt     fInvKyFractionalInt;
84
85    FixedTileProc       fTileProcX;         // chooseProcs
86    FixedTileProc       fTileProcY;         // chooseProcs
87    IntTileProc         fIntTileProcY;      // chooseProcs
88    SkFixed             fFilterOneX;
89    SkFixed             fFilterOneY;
90
91    SkFixed             fInvSx;             // chooseProcs
92    SkFixed             fInvKy;             // chooseProcs
93    SkPMColor           fPaintPMColor;      // chooseProcs - A8 config
94    uint16_t            fAlphaScale;        // chooseProcs
95
96    /** Platforms implement this, and can optionally overwrite only the
97        following fields:
98
99        fShaderProc32
100        fShaderProc16
101        fMatrixProc
102        fSampleProc32
103        fSampleProc32
104
105        They will already have valid function pointers, so a platform that does
106        not have an accelerated version can just leave that field as is. A valid
107        implementation can do nothing (see SkBitmapProcState_opts_none.cpp)
108     */
109    void platformProcs();
110
111    /** Given the byte size of the index buffer to be passed to the matrix proc,
112        return the maximum number of resulting pixels that can be computed
113        (i.e. the number of SkPMColor values to be written by the sample proc).
114        This routine takes into account that filtering and scale-vs-affine
115        affect the amount of buffer space needed.
116
117        Only valid to call after chooseProcs (setContext) has been called. It is
118        safe to call this inside the shader's shadeSpan() method.
119     */
120    int maxCountForBufferSize(size_t bufferSize) const;
121
122    // If a shader proc is present, then the corresponding matrix/sample procs
123    // are ignored
124    ShaderProc32 getShaderProc32() const { return fShaderProc32; }
125    ShaderProc16 getShaderProc16() const { return fShaderProc16; }
126
127#ifdef SK_DEBUG
128    MatrixProc getMatrixProc() const;
129#else
130    MatrixProc getMatrixProc() const { return fMatrixProc; }
131#endif
132    SampleProc32 getSampleProc32() const { return fSampleProc32; }
133
134private:
135    ShaderProc32        fShaderProc32;      // chooseProcs
136    ShaderProc16        fShaderProc16;      // chooseProcs
137    // These are used if the shaderproc is nullptr
138    MatrixProc          fMatrixProc;        // chooseProcs
139    SampleProc32        fSampleProc32;      // chooseProcs
140
141    MatrixProc chooseMatrixProc(bool trivial_matrix);
142    bool chooseProcs(); // caller must have called init() first (on our base-class)
143    bool chooseScanlineProcs(bool trivialMatrix, bool clampClamp);
144    ShaderProc32 chooseShaderProc32();
145
146    // Return false if we failed to setup for fast translate (e.g. overflow)
147    bool setupForTranslate();
148
149#ifdef SK_DEBUG
150    static void DebugMatrixProc(const SkBitmapProcState&,
151                                uint32_t[], int count, int x, int y);
152#endif
153};
154
155/*  Macros for packing and unpacking pairs of 16bit values in a 32bit uint.
156    Used to allow access to a stream of uint16_t either one at a time, or
157    2 at a time by unpacking a uint32_t
158 */
159#ifdef SK_CPU_BENDIAN
160    #define PACK_TWO_SHORTS(pri, sec) ((pri) << 16 | (sec))
161    #define UNPACK_PRIMARY_SHORT(packed)    ((uint32_t)(packed) >> 16)
162    #define UNPACK_SECONDARY_SHORT(packed)  ((packed) & 0xFFFF)
163#else
164    #define PACK_TWO_SHORTS(pri, sec) ((pri) | ((sec) << 16))
165    #define UNPACK_PRIMARY_SHORT(packed)    ((packed) & 0xFFFF)
166    #define UNPACK_SECONDARY_SHORT(packed)  ((uint32_t)(packed) >> 16)
167#endif
168
169#ifdef SK_DEBUG
170    static inline uint32_t pack_two_shorts(U16CPU pri, U16CPU sec) {
171        SkASSERT((uint16_t)pri == pri);
172        SkASSERT((uint16_t)sec == sec);
173        return PACK_TWO_SHORTS(pri, sec);
174    }
175#else
176    #define pack_two_shorts(pri, sec)   PACK_TWO_SHORTS(pri, sec)
177#endif
178
179// These functions are generated via macros, but are exposed here so that
180// platformProcs may test for them by name.
181void S32_opaque_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[],
182                              int count, SkPMColor colors[]);
183void S32_alpha_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[],
184                             int count, SkPMColor colors[]);
185void ClampX_ClampY_filter_scale(const SkBitmapProcState& s, uint32_t xy[],
186                                int count, int x, int y);
187void ClampX_ClampY_nofilter_scale(const SkBitmapProcState& s, uint32_t xy[],
188                                  int count, int x, int y);
189
190// Helper class for mapping the middle of pixel (x, y) into SkFractionalInt bitmap space.
191// Discussion:
192// Overall, this code takes a point in destination space, and uses the center of the pixel
193// at (x, y) to determine the sample point in source space. It then adjusts the pixel by different
194// amounts based in filtering and tiling.
195// This code can be broken into two main cases based on filtering:
196// * no filtering (nearest neighbor) - when using nearest neighbor filtering all tile modes reduce
197// the sampled by one ulp. If a simple point pt lies precisely on XXX.1/2 then it forced down
198// when positive making 1/2 + 1/2 = .999999 instead of 1.0.
199// * filtering - in the filtering case, the code calculates the -1/2 shift for starting the
200// bilerp kernel. There is a twist; there is a big difference between clamp and the other tile
201// modes. In tile and repeat the matrix has been reduced by an additional 1/width and 1/height
202// factor. This maps from destination space to [0, 1) (instead of source space) to allow easy
203// modulo arithmetic. This means that the -1/2 needed by bilerp is actually 1/2 * 1/width for x
204// and 1/2 * 1/height for y. This is what happens when the poorly named fFilterOne{X|Y} is
205// divided by two.
206class SkBitmapProcStateAutoMapper {
207public:
208    SkBitmapProcStateAutoMapper(const SkBitmapProcState& s, int x, int y,
209                                SkPoint* scalarPoint = nullptr) {
210        SkPoint pt;
211        s.fInvProc(s.fInvMatrix,
212                   SkIntToScalar(x) + SK_ScalarHalf,
213                   SkIntToScalar(y) + SK_ScalarHalf, &pt);
214
215        SkFixed biasX, biasY;
216        if (s.fFilterQuality == kNone_SkFilterQuality) {
217            // SkFixed epsilon bias to ensure inverse-mapped bitmap coordinates are rounded
218            // consistently WRT geometry.  Note that we only need the bias for positive scales:
219            // for negative scales, the rounding is intrinsically correct.
220            // We scale it to persist SkFractionalInt -> SkFixed conversions.
221            biasX = (s.fInvMatrix.getScaleX() > 0);
222            biasY = (s.fInvMatrix.getScaleY() > 0);
223        } else {
224            biasX = s.fFilterOneX >> 1;
225            biasY = s.fFilterOneY >> 1;
226        }
227
228        // punt to unsigned for defined underflow behavior
229        fX = (SkFractionalInt)((uint64_t)SkScalarToFractionalInt(pt.x()) -
230                               (uint64_t)SkFixedToFractionalInt(biasX));
231        fY = (SkFractionalInt)((uint64_t)SkScalarToFractionalInt(pt.y()) -
232                               (uint64_t)SkFixedToFractionalInt(biasY));
233
234        if (scalarPoint) {
235            scalarPoint->set(pt.x() - SkFixedToScalar(biasX),
236                             pt.y() - SkFixedToScalar(biasY));
237        }
238    }
239
240    SkFractionalInt fractionalIntX() const { return fX; }
241    SkFractionalInt fractionalIntY() const { return fY; }
242
243    SkFixed fixedX() const { return SkFractionalIntToFixed(fX); }
244    SkFixed fixedY() const { return SkFractionalIntToFixed(fY); }
245
246    int intX() const { return SkFractionalIntToInt(fX); }
247    int intY() const { return SkFractionalIntToInt(fY); }
248
249private:
250    SkFractionalInt fX, fY;
251};
252
253#endif
254