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