LCOV - app.info - gfx/skia/src/core/SkPictureFlat.h

LCOV - code coverage report
| Current view: | directory - gfx/skia/src/core - SkPictureFlat.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 42 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 18 | 0 | 0.0 %

           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                 : #ifndef SkPictureFlat_DEFINED
           9                 : #define SkPictureFlat_DEFINED
          10                 :
          11                 : #include "SkChunkAlloc.h"
          12                 : #include "SkBitmap.h"
          13                 : #include "SkPicture.h"
          14                 : #include "SkMatrix.h"
          15                 : #include "SkPaint.h"
          16                 : #include "SkPath.h"
          17                 : #include "SkRegion.h"
          18                 :
          19                 : enum DrawType {
          20                 :     UNUSED,
          21                 :     CLIP_PATH,
          22                 :     CLIP_REGION,
          23                 :     CLIP_RECT,
          24                 :     CONCAT,
          25                 :     DRAW_BITMAP,
          26                 :     DRAW_BITMAP_MATRIX,
          27                 :     DRAW_BITMAP_NINE,
          28                 :     DRAW_BITMAP_RECT,
          29                 :     DRAW_CLEAR,
          30                 :     DRAW_DATA,
          31                 :     DRAW_PAINT,
          32                 :     DRAW_PATH,
          33                 :     DRAW_PICTURE,
          34                 :     DRAW_POINTS,
          35                 :     DRAW_POS_TEXT,
          36                 :     DRAW_POS_TEXT_H,
          37                 :     DRAW_POS_TEXT_H_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT_H
          38                 :     DRAW_RECT,
          39                 :     DRAW_SPRITE,
          40                 :     DRAW_TEXT,
          41                 :     DRAW_TEXT_ON_PATH,
          42                 :     DRAW_TEXT_TOP_BOTTOM,   // fast variant of DRAW_TEXT
          43                 :     DRAW_VERTICES,
          44                 :     RESTORE,
          45                 :     ROTATE,
          46                 :     SAVE,
          47                 :     SAVE_LAYER,
          48                 :     SCALE,
          49                 :     SET_MATRIX,
          50                 :     SKEW,
          51                 :     TRANSLATE
          52                 : };
          53                 :
          54                 : enum DrawVertexFlags {
          55                 :     DRAW_VERTICES_HAS_TEXS    = 0x01,
          56                 :     DRAW_VERTICES_HAS_COLORS  = 0x02,
          57                 :     DRAW_VERTICES_HAS_INDICES = 0x04
          58                 : };
          59                 :
          60                 : ///////////////////////////////////////////////////////////////////////////////
          61                 : // clipparams are packed in 5 bits
          62                 : //  doAA:1 | regionOp:4
          63                 :
          64               0 : static inline uint32_t ClipParams_pack(SkRegion::Op op, bool doAA) {
          65               0 :     unsigned doAABit = doAA ? 1 : 0;
          66               0 :     return (doAABit << 4) | op;
          67                 : }
          68                 :
          69               0 : static inline SkRegion::Op ClipParams_unpackRegionOp(uint32_t packed) {
          70               0 :     return (SkRegion::Op)(packed & 0xF);
          71                 : }
          72                 :
          73               0 : static inline bool ClipParams_unpackDoAA(uint32_t packed) {
          74               0 :     return SkToBool((packed >> 4) & 1);
          75                 : }
          76                 :
          77                 : ///////////////////////////////////////////////////////////////////////////////
          78                 :
          79                 : class SkRefCntPlayback {
          80                 : public:
          81                 :     SkRefCntPlayback();
          82                 :     virtual ~SkRefCntPlayback();
          83                 :
          84                 :     int count() const { return fCount; }
          85                 :
          86                 :     void reset(const SkRefCntSet*);
          87                 :
          88                 :     void setCount(int count);
          89                 :     SkRefCnt* set(int index, SkRefCnt*);
          90                 :
          91               0 :     virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
          92               0 :         buffer.setRefCntArray(fArray, fCount);
          93               0 :     }
          94                 :
          95                 : protected:
          96                 :     int fCount;
          97                 :     SkRefCnt** fArray;
          98                 : };
          99                 :
         100               0 : class SkTypefacePlayback : public SkRefCntPlayback {
         101                 : public:
         102               0 :     virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
         103               0 :         buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
         104               0 :     }
         105                 : };
         106                 :
         107                 : class SkFactoryPlayback {
         108                 : public:
         109               0 :     SkFactoryPlayback(int count) : fCount(count) {
         110               0 :         fArray = SkNEW_ARRAY(SkFlattenable::Factory, count);
         111               0 :     }
         112                 :
         113               0 :     ~SkFactoryPlayback() {
         114               0 :         SkDELETE_ARRAY(fArray);
         115               0 :     }
         116                 :
         117               0 :     SkFlattenable::Factory* base() const { return fArray; }
         118                 :
         119               0 :     void setupBuffer(SkFlattenableReadBuffer& buffer) const {
         120               0 :         buffer.setFactoryPlayback(fArray, fCount);
         121               0 :     }
         122                 :
         123                 : private:
         124                 :     int fCount;
         125                 :     SkFlattenable::Factory* fArray;
         126                 : };
         127                 :
         128                 : class SkFlatData {
         129                 : public:
         130               0 :     static int Compare(const SkFlatData* a, const SkFlatData* b) {
         131               0 :         return memcmp(&a->fAllocSize, &b->fAllocSize, a->fAllocSize);
         132                 :     }
         133                 :
         134               0 :     int index() const { return fIndex; }
         135                 :
         136                 : #ifdef SK_DEBUG_SIZE
         137                 :     size_t size() const { return sizeof(fIndex) + fAllocSize; }
         138                 : #endif
         139                 :
         140                 : protected:
         141                 :     static SkFlatData* Alloc(SkChunkAlloc* heap, int32_t size, int index);
         142                 :
         143                 :     int fIndex;
         144                 :     int32_t fAllocSize;
         145                 : };
         146                 :
         147                 : class SkFlatBitmap : public SkFlatData {
         148                 : public:
         149                 :     static SkFlatBitmap* Flatten(SkChunkAlloc*, const SkBitmap&, int index,
         150                 :                                  SkRefCntSet*);
         151                 :
         152               0 :     void unflatten(SkBitmap* bitmap, SkRefCntPlayback* rcp) const {
         153               0 :         SkFlattenableReadBuffer buffer(fBitmapData);
         154               0 :         if (rcp) {
         155               0 :             rcp->setupBuffer(buffer);
         156                 :         }
         157               0 :         bitmap->unflatten(buffer);
         158               0 :     }
         159                 :
         160                 : #ifdef SK_DEBUG_VALIDATE
         161                 :     void validate() const {
         162                 :         // to be written
         163                 :     }
         164                 : #endif
         165                 :
         166                 : private:
         167                 :     char fBitmapData[1];
         168                 :     typedef SkFlatData INHERITED;
         169                 : };
         170                 :
         171                 : class SkFlatMatrix : public SkFlatData {
         172                 : public:
         173                 :     static SkFlatMatrix* Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index);
         174                 :
         175               0 :     void unflatten(SkMatrix* result) const {
         176               0 :         result->unflatten(fMatrixData);
         177               0 :     }
         178                 :
         179                 : #ifdef SK_DEBUG_DUMP
         180                 :     void dump() const;
         181                 : #endif
         182                 :
         183                 : #ifdef SK_DEBUG_VALIDATE
         184                 :     void validate() const {
         185                 :         // to be written
         186                 :     }
         187                 : #endif
         188                 :
         189                 : private:
         190                 :     char fMatrixData[1];
         191                 :     typedef SkFlatData INHERITED;
         192                 : };
         193                 :
         194                 : class SkFlatPaint : public SkFlatData {
         195                 : public:
         196                 :     static SkFlatPaint* Flatten(SkChunkAlloc* heap, const SkPaint& paint,
         197                 :                                 int index, SkRefCntSet*,
         198                 :                                 SkRefCntSet* faceRecorder);
         199                 :
         200               0 :     void unflatten(SkPaint* result, SkRefCntPlayback* rcp,
         201                 :                    SkTypefacePlayback* facePlayback) const {
         202               0 :         Read(fPaintData, result, rcp, facePlayback);
         203               0 :     }
         204                 :
         205                 :     static void Read(const void* storage, SkPaint* paint, SkRefCntPlayback*,
         206                 :                      SkTypefacePlayback* facePlayback);
         207                 :
         208                 : #ifdef SK_DEBUG_DUMP
         209                 :     void dump() const;
         210                 : #endif
         211                 :
         212                 : private:
         213                 :     char fPaintData[1];
         214                 :     typedef SkFlatData INHERITED;
         215                 : };
         216                 :
         217                 : class SkFlatRegion : public SkFlatData {
         218                 : public:
         219                 :     static SkFlatRegion* Flatten(SkChunkAlloc* heap, const SkRegion& region, int index);
         220                 :
         221               0 :     void unflatten(SkRegion* result) const {
         222               0 :         result->unflatten(fRegionData);
         223               0 :     }
         224                 :
         225                 : #ifdef SK_DEBUG_VALIDATE
         226                 :     void validate() const {
         227                 :         // to be written
         228                 :     }
         229                 : #endif
         230                 :
         231                 : private:
         232                 :     char fRegionData[1];
         233                 :     typedef SkFlatData INHERITED;
         234                 : };
         235                 :
         236                 : #endif

Generated by: LCOV version 1.7