skia2/include/core/SkWriteBuffer.h

/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkWriteBuffer_DEFINED
#define SkWriteBuffer_DEFINED

#include "SkData.h"
#include "SkImage.h"
#include "SkPath.h"
#include "SkPicture.h"
#include "SkPixelSerializer.h"
#include "SkRefCnt.h"
#include "SkWriter32.h"
#include "../private/SkTHash.h"

class SkBitmap;
class SkDeduper;
class SkFactorySet;
class SkFlattenable;
class SkRefCntSet;

class SK_API SkWriteBuffer {
public:
    SkWriteBuffer() {}
    virtual ~SkWriteBuffer() {}

    virtual bool isCrossProcess() const = 0;

    virtual void writeByteArray(const void* data, size_t size) = 0;
    void writeDataAsByteArray(SkData* data) {
        this->writeByteArray(data->data(), data->size());
    }
    virtual void writeBool(bool value) = 0;
    virtual void writeScalar(SkScalar value) = 0;
    virtual void writeScalarArray(const SkScalar* value, uint32_t count) = 0;
    virtual void writeInt(int32_t value) = 0;
    virtual void writeIntArray(const int32_t* value, uint32_t count) = 0;
    virtual void writeUInt(uint32_t value) = 0;
    void write32(int32_t value) {
        this->writeInt(value);
    }
    virtual void writeString(const char* value) = 0;

    virtual void writeFlattenable(const SkFlattenable* flattenable) = 0;
    virtual void writeColor(SkColor color) = 0;
    virtual void writeColorArray(const SkColor* color, uint32_t count) = 0;
    virtual void writeColor4f(const SkColor4f& color) = 0;
    virtual void writeColor4fArray(const SkColor4f* color, uint32_t count) = 0;
    virtual void writePoint(const SkPoint& point) = 0;
    virtual void writePointArray(const SkPoint* point, uint32_t count) = 0;
    virtual void writeMatrix(const SkMatrix& matrix) = 0;
    virtual void writeIRect(const SkIRect& rect) = 0;
    virtual void writeRect(const SkRect& rect) = 0;
    virtual void writeRegion(const SkRegion& region) = 0;
    virtual void writePath(const SkPath& path) = 0;
    virtual size_t writeStream(SkStream* stream, size_t length) = 0;
    virtual void writeImage(const SkImage*) = 0;
    virtual void writeTypeface(SkTypeface* typeface) = 0;
    virtual void writePaint(const SkPaint& paint) = 0;

    void setDeduper(SkDeduper* deduper) { fDeduper = deduper; }

    /**
     *  Return a client specified context pointer. This is not interpreted by the writebuffer.
     *  It defaults to nullptr, but may be set with setClientContext(...).
     */
    void* getClientContext() const { return fClientCtx; }

    /**
     *  Set the client specified context pointer. This is not interpreted by the writebuffer.
     *  It defaults to nullptr. It can be inspected by calling getClientContext().
     */
    void setClientContext(void* ctx) { fClientCtx = ctx; }

protected:
    SkDeduper* fDeduper = nullptr;
    void*      fClientCtx = nullptr;
};

/**
 * Concrete implementation that serializes to a flat binary blob.
 */
class SK_API SkBinaryWriteBuffer : public SkWriteBuffer {
public:
    enum Flags {
        kCrossProcess_Flag = 1 << 0,
    };

    SkBinaryWriteBuffer(uint32_t flags = 0);
    SkBinaryWriteBuffer(void* initialStorage, size_t storageSize, uint32_t flags = 0);
    ~SkBinaryWriteBuffer() override;

    bool isCrossProcess() const override {
        return SkToBool(fFlags & kCrossProcess_Flag);
    }

    void write(const void* buffer, size_t bytes) {
        fWriter.write(buffer, bytes);
    }

    void reset(void* storage = nullptr, size_t storageSize = 0) {
        fWriter.reset(storage, storageSize);
    }

    size_t bytesWritten() const { return fWriter.bytesWritten(); }

    void writeByteArray(const void* data, size_t size) override;
    void writeBool(bool value) override;
    void writeScalar(SkScalar value) override;
    void writeScalarArray(const SkScalar* value, uint32_t count) override;
    void writeInt(int32_t value) override;
    void writeIntArray(const int32_t* value, uint32_t count) override;
    void writeUInt(uint32_t value) override;
    void writeString(const char* value) override;

    void writeFlattenable(const SkFlattenable* flattenable) override;
    void writeColor(SkColor color) override;
    void writeColorArray(const SkColor* color, uint32_t count) override;
    void writeColor4f(const SkColor4f& color) override;
    void writeColor4fArray(const SkColor4f* color, uint32_t count) override;
    void writePoint(const SkPoint& point) override;
    void writePointArray(const SkPoint* point, uint32_t count) override;
    void writeMatrix(const SkMatrix& matrix) override;
    void writeIRect(const SkIRect& rect) override;
    void writeRect(const SkRect& rect) override;
    void writeRegion(const SkRegion& region) override;
    void writePath(const SkPath& path) override;
    size_t writeStream(SkStream* stream, size_t length) override;
    void writeImage(const SkImage*) override;
    void writeTypeface(SkTypeface* typeface) override;
    void writePaint(const SkPaint& paint) override;

    bool writeToStream(SkWStream*);
    void writeToMemory(void* dst) { fWriter.flatten(dst); }

    SkFactorySet* setFactoryRecorder(SkFactorySet*);
    SkRefCntSet* setTypefaceRecorder(SkRefCntSet*);

    /**
     * Set an SkPixelSerializer to store an encoded representation of pixels,
     * e.g. SkBitmaps.
     *
     * TODO: Encode SkImage pixels as well.
     */
    void setPixelSerializer(sk_sp<SkPixelSerializer>);
    SkPixelSerializer* getPixelSerializer() const { return fPixelSerializer.get(); }

private:
    const uint32_t fFlags;
    SkFactorySet* fFactorySet;
    SkWriter32 fWriter;

    SkRefCntSet* fTFSet;

    sk_sp<SkPixelSerializer> fPixelSerializer;

    // Only used if we do not have an fFactorySet
    SkTHashMap<SkString, uint32_t> fFlattenableDict;
};

#endif // SkWriteBuffer_DEFINED