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