1 2 /* 3 * Copyright 2011 Google Inc. 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 11 #ifndef SkGPipePriv_DEFINED 12 #define SkGPipePriv_DEFINED 13 14 #include "SkTypes.h" 15 16 #define UNIMPLEMENTED 17 18 // these must be contiguous, 0...N-1 19 enum PaintFlats { 20 kColorFilter_PaintFlat, 21 kDrawLooper_PaintFlat, 22 kMaskFilter_PaintFlat, 23 kPathEffect_PaintFlat, 24 kRasterizer_PaintFlat, 25 kShader_PaintFlat, 26 kImageFilter_PaintFlat, 27 kXfermode_PaintFlat, 28 29 kLast_PaintFlat = kXfermode_PaintFlat 30 }; 31 #define kCount_PaintFlats (kLast_PaintFlat + 1) 32 33 enum DrawOps { 34 kSkip_DrawOp, // skip an addition N bytes (N == data) 35 36 // these match Canvas apis 37 kClipPath_DrawOp, 38 kClipRegion_DrawOp, 39 kClipRect_DrawOp, 40 kClipRRect_DrawOp, 41 kConcat_DrawOp, 42 kDrawBitmap_DrawOp, 43 kDrawBitmapMatrix_DrawOp, 44 kDrawBitmapNine_DrawOp, 45 kDrawBitmapRectToRect_DrawOp, 46 kDrawClear_DrawOp, 47 kDrawData_DrawOp, 48 kDrawOval_DrawOp, 49 kDrawPaint_DrawOp, 50 kDrawPath_DrawOp, 51 kDrawPicture_DrawOp, 52 kDrawPoints_DrawOp, 53 kDrawPosText_DrawOp, 54 kDrawPosTextH_DrawOp, 55 kDrawRect_DrawOp, 56 kDrawRRect_DrawOp, 57 kDrawSprite_DrawOp, 58 kDrawText_DrawOp, 59 kDrawTextOnPath_DrawOp, 60 kDrawVertices_DrawOp, 61 kRestore_DrawOp, 62 kRotate_DrawOp, 63 kSave_DrawOp, 64 kSaveLayer_DrawOp, 65 kScale_DrawOp, 66 kSetMatrix_DrawOp, 67 kSkew_DrawOp, 68 kTranslate_DrawOp, 69 70 kPaintOp_DrawOp, 71 kSetTypeface_DrawOp, 72 73 kDef_Typeface_DrawOp, 74 kDef_Flattenable_DrawOp, 75 kDef_Bitmap_DrawOp, 76 kDef_Factory_DrawOp, 77 78 // these are signals to playback, not drawing verbs 79 kReportFlags_DrawOp, 80 kShareBitmapHeap_DrawOp, 81 kDone_DrawOp, 82 }; 83 84 /** 85 * DrawOp packs into a 32bit int as follows 86 * 87 * DrawOp:8 - Flags:4 - Data:20 88 * 89 * Flags and Data are called out separately, so we can reuse Data between 90 * different Ops that might have different Flags. e.g. Data might be a Paint 91 * index for both drawRect (no flags) and saveLayer (does have flags). 92 * 93 * All Ops that take a SkPaint use their Data field to store the index to 94 * the paint (previously defined with kPaintOp_DrawOp). 95 */ 96 97 #define DRAWOPS_OP_BITS 8 98 #define DRAWOPS_FLAG_BITS 4 99 #define DRAWOPS_DATA_BITS 20 100 101 #define DRAWOPS_OP_MASK ((1 << DRAWOPS_OP_BITS) - 1) 102 #define DRAWOPS_FLAG_MASK ((1 << DRAWOPS_FLAG_BITS) - 1) 103 #define DRAWOPS_DATA_MASK ((1 << DRAWOPS_DATA_BITS) - 1) 104 105 static inline unsigned DrawOp_unpackOp(uint32_t op32) { 106 return (op32 >> (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS)); 107 } 108 109 static inline unsigned DrawOp_unpackFlags(uint32_t op32) { 110 return (op32 >> DRAWOPS_DATA_BITS) & DRAWOPS_FLAG_MASK; 111 } 112 113 static inline unsigned DrawOp_unpackData(uint32_t op32) { 114 return op32 & DRAWOPS_DATA_MASK; 115 } 116 117 static inline uint32_t DrawOp_packOpFlagData(DrawOps op, unsigned flags, unsigned data) { 118 SkASSERT(0 == (op & ~DRAWOPS_OP_MASK)); 119 SkASSERT(0 == (flags & ~DRAWOPS_FLAG_MASK)); 120 SkASSERT(0 == (data & ~DRAWOPS_DATA_MASK)); 121 122 return (op << (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS)) | 123 (flags << DRAWOPS_DATA_BITS) | 124 data; 125 } 126 127 /** DrawOp specific flag bits 128 */ 129 130 enum { 131 kSaveLayer_HasBounds_DrawOpFlag = 1 << 0, 132 kSaveLayer_HasPaint_DrawOpFlag = 1 << 1, 133 }; 134 enum { 135 kClear_HasColor_DrawOpFlag = 1 << 0 136 }; 137 enum { 138 kDrawTextOnPath_HasMatrix_DrawOpFlag = 1 << 0 139 }; 140 enum { 141 kDrawVertices_HasTexs_DrawOpFlag = 1 << 0, 142 kDrawVertices_HasColors_DrawOpFlag = 1 << 1, 143 kDrawVertices_HasIndices_DrawOpFlag = 1 << 2, 144 }; 145 enum { 146 kDrawBitmap_HasPaint_DrawOpFlag = 1 << 0, 147 // Specific to drawBitmapRect, but needs to be different from HasPaint, 148 // which is used for all drawBitmap calls, so include it here. 149 kDrawBitmap_HasSrcRect_DrawOpFlag = 1 << 1, 150 }; 151 enum { 152 kClip_HasAntiAlias_DrawOpFlag = 1 << 0, 153 }; 154 /////////////////////////////////////////////////////////////////////////////// 155 156 class BitmapInfo : SkNoncopyable { 157 public: 158 BitmapInfo(SkBitmap* bitmap, uint32_t genID, int toBeDrawnCount) 159 : fBitmap(bitmap) 160 , fGenID(genID) 161 , fBytesAllocated(0) 162 , fMoreRecentlyUsed(NULL) 163 , fLessRecentlyUsed(NULL) 164 , fToBeDrawnCount(toBeDrawnCount) 165 {} 166 167 ~BitmapInfo() { 168 SkASSERT(0 == fToBeDrawnCount); 169 SkDELETE(fBitmap); 170 } 171 172 void addDraws(int drawsToAdd) { 173 if (0 == fToBeDrawnCount) { 174 // The readers will only ever decrement the count, so once the 175 // count is zero, the writer will be the only one modifying it, 176 // so it does not need to be an atomic operation. 177 fToBeDrawnCount = drawsToAdd; 178 } else { 179 sk_atomic_add(&fToBeDrawnCount, drawsToAdd); 180 } 181 } 182 183 void decDraws() { 184 sk_atomic_dec(&fToBeDrawnCount); 185 } 186 187 int drawCount() const { 188 return fToBeDrawnCount; 189 } 190 191 SkBitmap* fBitmap; 192 // Store the generation ID of the original bitmap, since copying does 193 // not copy this field, so fBitmap's generation ID will not be useful 194 // for comparing. 195 // FIXME: Is it reasonable to make copying a bitmap/pixelref copy the 196 // generation ID? 197 uint32_t fGenID; 198 // Keep track of the bytes allocated for this bitmap. When replacing the 199 // bitmap or removing this BitmapInfo we know how much memory has been 200 // reclaimed. 201 size_t fBytesAllocated; 202 // TODO: Generalize the LRU caching mechanism 203 BitmapInfo* fMoreRecentlyUsed; 204 BitmapInfo* fLessRecentlyUsed; 205 private: 206 int fToBeDrawnCount; 207 }; 208 209 static inline bool shouldFlattenBitmaps(uint32_t flags) { 210 return SkToBool(flags & SkGPipeWriter::kCrossProcess_Flag 211 && !(flags & SkGPipeWriter::kSharedAddressSpace_Flag)); 212 } 213 214 /////////////////////////////////////////////////////////////////////////////// 215 216 enum PaintOps { 217 kReset_PaintOp, // no arg 218 219 kFlags_PaintOp, // arg inline 220 kColor_PaintOp, // arg 32 221 kStyle_PaintOp, // arg inline 222 kJoin_PaintOp, // arg inline 223 kCap_PaintOp, // arg inline 224 kWidth_PaintOp, // arg scalar 225 kMiter_PaintOp,// arg scalar 226 227 kEncoding_PaintOp, // arg inline - text 228 kHinting_PaintOp, // arg inline - text 229 kAlign_PaintOp, // arg inline - text 230 kTextSize_PaintOp, // arg scalar - text 231 kTextScaleX_PaintOp,// arg scalar - text 232 kTextSkewX_PaintOp, // arg scalar - text 233 kTypeface_PaintOp, // arg inline (index) - text 234 235 kFlatIndex_PaintOp, // flags=paintflat, data=index 236 }; 237 238 #define PAINTOPS_OP_BITS 8 239 #define PAINTOPS_FLAG_BITS 4 240 #define PAINTOPS_DATA_BITS 20 241 242 #define PAINTOPS_OP_MASK ((1 << PAINTOPS_OP_BITS) - 1) 243 #define PAINTOPS_FLAG_MASK ((1 << PAINTOPS_FLAG_BITS) - 1) 244 #define PAINTOPS_DATA_MASK ((1 << PAINTOPS_DATA_BITS) - 1) 245 246 static inline unsigned PaintOp_unpackOp(uint32_t op32) { 247 return (op32 >> (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)); 248 } 249 250 static inline unsigned PaintOp_unpackFlags(uint32_t op32) { 251 return (op32 >> PAINTOPS_DATA_BITS) & PAINTOPS_FLAG_MASK; 252 } 253 254 static inline unsigned PaintOp_unpackData(uint32_t op32) { 255 return op32 & PAINTOPS_DATA_MASK; 256 } 257 258 static inline uint32_t PaintOp_packOp(PaintOps op) { 259 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK)); 260 261 return op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS); 262 } 263 264 static inline uint32_t PaintOp_packOpData(PaintOps op, unsigned data) { 265 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK)); 266 SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK)); 267 268 return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) | data; 269 } 270 271 static inline uint32_t PaintOp_packOpFlagData(PaintOps op, unsigned flags, unsigned data) { 272 SkASSERT(0 == (op & ~PAINTOPS_OP_MASK)); 273 SkASSERT(0 == (flags & ~PAINTOPS_FLAG_MASK)); 274 SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK)); 275 276 return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) | 277 (flags << PAINTOPS_DATA_BITS) | 278 data; 279 } 280 281 #endif 282
