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