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