src/third_party/skia/include/core/SkWriteBuffer.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 #ifndef SkWriteBuffer_DEFINED
  10 #define SkWriteBuffer_DEFINED
  11
  12 #include "SkBitmapHeap.h"
  13 #include "SkData.h"
  14 #include "SkPath.h"
  15 #include "SkPicture.h"
  16 #include "SkRefCnt.h"
  17 #include "SkWriter32.h"
  18
  19 class SkBitmap;
  20 class SkFactorySet;
  21 class SkFlattenable;
  22 class SkNamedFactorySet;
  23 class SkRefCntSet;
  24
  25 class SkWriteBuffer {
  26 public:
  27     enum Flags {
  28         kCrossProcess_Flag  = 1 << 0,
  29         kValidation_Flag    = 1 << 1,
  30     };
  31
  32     SkWriteBuffer(uint32_t flags = 0);
  33     SkWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
  34     ~SkWriteBuffer();
  35
  36     bool isCrossProcess() const {
  37         return this->isValidating() || SkToBool(fFlags & kCrossProcess_Flag);
  38     }
  39
  40     SkWriter32* getWriter32() { return &fWriter; }
  41     void reset(void* storage = NULL, size_t storageSize = 0) {
  42         fWriter.reset(storage, storageSize);
  43     }
  44
  45     uint32_t* reserve(size_t size) { return fWriter.reserve(size); }
  46
  47     size_t bytesWritten() const { return fWriter.bytesWritten(); }
  48
  49     void writeByteArray(const void* data, size_t size);
  50     void writeDataAsByteArray(SkData* data) { this->writeByteArray(data->data(), data->size()); }
  51     void writeBool(bool value);
  52     void writeFixed(SkFixed value);
  53     void writeScalar(SkScalar value);
  54     void writeScalarArray(const SkScalar* value, uint32_t count);
  55     void writeInt(int32_t value);
  56     void writeIntArray(const int32_t* value, uint32_t count);
  57     void writeUInt(uint32_t value);
  58     void write32(int32_t value);
  59     void writeString(const char* value);
  60     void writeEncodedString(const void* value, size_t byteLength, SkPaint::TextEncoding encoding);
  61     void writeFunctionPtr(void* ptr) { this->writeByteArray(&ptr, sizeof(ptr)); }
  62
  63     void writeFlattenable(const SkFlattenable* flattenable);
  64     void writeColor(const SkColor& color);
  65     void writeColorArray(const SkColor* color, uint32_t count);
  66     void writePoint(const SkPoint& point);
  67     void writePointArray(const SkPoint* point, uint32_t count);
  68     void writeMatrix(const SkMatrix& matrix);
  69     void writeIRect(const SkIRect& rect);
  70     void writeRect(const SkRect& rect);
  71     void writeRegion(const SkRegion& region);
  72     void writePath(const SkPath& path);
  73     size_t writeStream(SkStream* stream, size_t length);
  74     void writeBitmap(const SkBitmap& bitmap);
  75     void writeTypeface(SkTypeface* typeface);
  76     void writePaint(const SkPaint& paint) { paint.flatten(*this); }
  77
  78     bool writeToStream(SkWStream*);
  79     void writeToMemory(void* dst) { fWriter.flatten(dst); }
  80
  81     SkFactorySet* setFactoryRecorder(SkFactorySet*);
  82     SkNamedFactorySet* setNamedFactoryRecorder(SkNamedFactorySet*);
  83
  84     SkRefCntSet* getTypefaceRecorder() const { return fTFSet; }
  85     SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);
  86
  87     /**
  88      * Set an SkBitmapHeap to store bitmaps rather than flattening.
  89      *
  90      * Incompatible with an EncodeBitmap function. If an EncodeBitmap function is set, setting an
  91      * SkBitmapHeap will set the function to NULL in release mode and crash in debug.
  92      */
  93     void setBitmapHeap(SkBitmapHeap*);
  94
  95     /**
  96      * Provide a function to encode an SkBitmap to an SkData. writeBitmap will attempt to use
  97      * bitmapEncoder to store the SkBitmap. If the reader does not provide a function to decode, it
  98      * will not be able to restore SkBitmaps, but will still be able to read the rest of the stream.
  99      * bitmapEncoder will never be called with a NULL pixelRefOffset.
 100      *
 101      * Incompatible with the SkBitmapHeap. If an encoder is set fBitmapHeap will be set to NULL in
 102      * release and crash in debug.
 103      */
 104     void setBitmapEncoder(SkPicture::EncodeBitmap bitmapEncoder);
 105
 106 private:
 107     bool isValidating() const { return SkToBool(fFlags & kValidation_Flag); }
 108
 109     const uint32_t fFlags;
 110     SkFactorySet* fFactorySet;
 111     SkNamedFactorySet* fNamedFactorySet;
 112     SkWriter32 fWriter;
 113
 114     SkBitmapHeap* fBitmapHeap;
 115     SkRefCntSet* fTFSet;
 116
 117     SkPicture::EncodeBitmap fBitmapEncoder;
 118 };
 119
 120 #endif // SkWriteBuffer_DEFINED