src/third_party/skia/src/pipe/SkGPipePriv.h

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