1 /* 2 ** Copyright 2007, The Android Open Source Project 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 #ifndef SkBitmapProcState_DEFINED 18 #define SkBitmapProcState_DEFINED 19 20 #include "SkBitmap.h" 21 #include "SkMatrix.h" 22 23 class SkPaint; 24 25 struct SkBitmapProcState { 26 27 typedef void (*ShaderProc32)(const SkBitmapProcState&, int x, int y, 28 SkPMColor[], int count); 29 30 typedef void (*ShaderProc16)(const SkBitmapProcState&, int x, int y, 31 uint16_t[], int count); 32 33 typedef void (*MatrixProc)(const SkBitmapProcState&, 34 uint32_t bitmapXY[], 35 int count, 36 int x, int y); 37 38 typedef void (*SampleProc32)(const SkBitmapProcState&, 39 const uint32_t[], 40 int count, 41 SkPMColor colors[]); 42 43 typedef void (*SampleProc16)(const SkBitmapProcState&, 44 const uint32_t[], 45 int count, 46 uint16_t colors[]); 47 48 typedef U16CPU (*FixedTileProc)(SkFixed); // returns 0..0xFFFF 49 typedef U16CPU (*IntTileProc)(int value, int count); // returns 0..count-1 50 51 // If a shader proc is present, then the corresponding matrix/sample procs 52 // are ignored 53 ShaderProc32 fShaderProc32; // chooseProcs 54 ShaderProc16 fShaderProc16; // chooseProcs 55 // These are used if the shaderproc is NULL 56 MatrixProc fMatrixProc; // chooseProcs 57 SampleProc32 fSampleProc32; // chooseProcs 58 SampleProc16 fSampleProc16; // chooseProcs 59 60 const SkBitmap* fBitmap; // chooseProcs - orig or mip 61 const SkMatrix* fInvMatrix; // chooseProcs 62 SkMatrix::MapXYProc fInvProc; // chooseProcs 63 64 FixedTileProc fTileProcX; // chooseProcs 65 FixedTileProc fTileProcY; // chooseProcs 66 IntTileProc fIntTileProcY; // chooseProcs 67 SkFixed fFilterOneX; 68 SkFixed fFilterOneY; 69 70 SkPMColor fPaintPMColor; // chooseProcs - A8 config 71 SkFixed fInvSx; // chooseProcs 72 SkFixed fInvKy; // chooseProcs 73 uint16_t fAlphaScale; // chooseProcs 74 uint8_t fInvType; // chooseProcs 75 uint8_t fTileModeX; // CONSTRUCTOR 76 uint8_t fTileModeY; // CONSTRUCTOR 77 SkBool8 fDoFilter; // chooseProcs 78 79 /** Platforms implement this, and can optionally overwrite only the 80 following fields: 81 82 fShaderProc32 83 fShaderProc16 84 fMatrixProc 85 fSampleProc32 86 fSampleProc32 87 88 They will already have valid function pointers, so a platform that does 89 not have an accelerated version can just leave that field as is. A valid 90 implementation can do nothing (see SkBitmapProcState_opts_none.cpp) 91 */ 92 void platformProcs(); 93 94 /** Given the byte size of the index buffer to be passed to the matrix proc, 95 return the maximum number of resulting pixels that can be computed 96 (i.e. the number of SkPMColor values to be written by the sample proc). 97 This routine takes into account that filtering and scale-vs-affine 98 affect the amount of buffer space needed. 99 100 Only valid to call after chooseProcs (setContext) has been called. It is 101 safe to call this inside the shader's shadeSpan() method. 102 */ 103 int maxCountForBufferSize(size_t bufferSize) const; 104 105 private: 106 friend class SkBitmapProcShader; 107 108 SkMatrix fUnitInvMatrix; // chooseProcs 109 SkBitmap fOrigBitmap; // CONSTRUCTOR 110 SkBitmap fMipBitmap; 111 112 MatrixProc chooseMatrixProc(bool trivial_matrix); 113 bool chooseProcs(const SkMatrix& inv, const SkPaint&); 114 }; 115 116 /* Macros for packing and unpacking pairs of 16bit values in a 32bit uint. 117 Used to allow access to a stream of uint16_t either one at a time, or 118 2 at a time by unpacking a uint32_t 119 */ 120 #ifdef SK_CPU_BENDIAN 121 #define PACK_TWO_SHORTS(pri, sec) ((pri) << 16 | (sec)) 122 #define UNPACK_PRIMARY_SHORT(packed) ((uint32_t)(packed) >> 16) 123 #define UNPACK_SECONDARY_SHORT(packed) ((packed) & 0xFFFF) 124 #else 125 #define PACK_TWO_SHORTS(pri, sec) ((pri) | ((sec) << 16)) 126 #define UNPACK_PRIMARY_SHORT(packed) ((packed) & 0xFFFF) 127 #define UNPACK_SECONDARY_SHORT(packed) ((uint32_t)(packed) >> 16) 128 #endif 129 130 #ifdef SK_DEBUG pack_two_shorts(U16CPU pri,U16CPU sec)131 static inline uint32_t pack_two_shorts(U16CPU pri, U16CPU sec) { 132 SkASSERT((uint16_t)pri == pri); 133 SkASSERT((uint16_t)sec == sec); 134 return PACK_TWO_SHORTS(pri, sec); 135 } 136 #else 137 #define pack_two_shorts(pri, sec) PACK_TWO_SHORTS(pri, sec) 138 #endif 139 140 // These functions are generated via macros, but are exposed here so that 141 // platformProcs may test for them by name. 142 void S32_opaque_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[], 143 int count, SkPMColor colors[]); 144 void S32_alpha_D32_filter_DX(const SkBitmapProcState& s, const uint32_t xy[], 145 int count, SkPMColor colors[]); 146 147 #endif 148