SkBinaryWriteBuffer Class Reference

#include <SkWriteBuffer.h>

Inheritance diagram for SkBinaryWriteBuffer:

Public Member Functions
	SkBinaryWriteBuffer (const SkSerialProcs &)
	SkBinaryWriteBuffer (void *initialStorage, size_t storageSize, const SkSerialProcs &)
	~SkBinaryWriteBuffer () override
void	write (const void *buffer, size_t bytes)
void	writePad32 (const void *buffer, size_t bytes) override
void	reset (void *storage=nullptr, size_t storageSize=0)
size_t	bytesWritten () const
bool	usingInitialStorage () const
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 (std::string_view 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	writePoint3 (const SkPoint3 &point) override
void	write (const SkM44 &) 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	writeSampling (const SkSamplingOptions &) 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 *) const
void	writeToMemory (void *dst) const
sk_sp< SkData >	snapshotAsData () const
void	setFactoryRecorder (sk_sp< SkFactorySet >)
void	setTypefaceRecorder (sk_sp< SkRefCntSet >)
Public Member Functions inherited from SkWriteBuffer
	SkWriteBuffer (const SkSerialProcs &p)
virtual	~SkWriteBuffer ()
void	writeDataAsByteArray (const SkData *data)
void	write32 (int32_t value)
const SkSerialProcs &	serialProcs () const

Additional Inherited Members
Protected Attributes inherited from SkWriteBuffer
SkSerialProcs	fProcs

Detailed Description

Concrete implementation that serializes to a flat binary blob.

Definition at line 97 of file SkWriteBuffer.h.

Constructor & Destructor Documentation

SkBinaryWriteBuffer() [1/2]

SkBinaryWriteBuffer::SkBinaryWriteBuffer

(

const SkSerialProcs &

p

)

Definition at line 42 of file SkWriteBuffer.cpp.

        : SkWriteBuffer(p), fFactorySet(nullptr), fTFSet(nullptr) {}

SkBinaryWriteBuffer() [2/2]

SkBinaryWriteBuffer::SkBinaryWriteBuffer	(	void *	initialStorage,
		size_t	storageSize,
		const SkSerialProcs &	p
	)

Definition at line 45 of file SkWriteBuffer.cpp.

        : SkWriteBuffer(p), fFactorySet(nullptr), fTFSet(nullptr), fWriter(storage, storageSize) {}

~SkBinaryWriteBuffer()

SkBinaryWriteBuffer::~SkBinaryWriteBuffer ( )

override

Definition at line 48 of file SkWriteBuffer.cpp.

{}

Member Function Documentation

bytesWritten()

size_t SkBinaryWriteBuffer::bytesWritten ( ) const

inline

Definition at line 114 of file SkWriteBuffer.h.

{ return fWriter.bytesWritten(); }

reset()

void SkBinaryWriteBuffer::reset ( void *  storage = nullptr, size_t  storageSize = 0  )

inline

Definition at line 110 of file SkWriteBuffer.h.

                                                                {
        fWriter.reset(storage, storageSize);
    }

setFactoryRecorder()

void SkBinaryWriteBuffer::setFactoryRecorder

(

sk_sp< SkFactorySet >

rec

)

Definition at line 274 of file SkWriteBuffer.cpp.

                                                                    {
    fFactorySet = std::move(rec);
}

setTypefaceRecorder()

void SkBinaryWriteBuffer::setTypefaceRecorder

(

sk_sp< SkRefCntSet >

rec

)

Definition at line 278 of file SkWriteBuffer.cpp.

                                                                    {
    fTFSet = std::move(rec);
}

snapshotAsData()

sk_sp< SkData > SkBinaryWriteBuffer::snapshotAsData ( ) const

inline

Definition at line 151 of file SkWriteBuffer.h.

{ return fWriter.snapshotAsData(); }

usingInitialStorage()

bool SkBinaryWriteBuffer::usingInitialStorage

(

)

const

Definition at line 50 of file SkWriteBuffer.cpp.

                                                    {
    return fWriter.usingInitialStorage();
}

write() [1/2]

void SkBinaryWriteBuffer::write ( const SkM44 &  matrix )

overridevirtual

Implements SkWriteBuffer.

Definition at line 121 of file SkWriteBuffer.cpp.

                                                   {
    fWriter.write(SkMatrixPriv::M44ColMajor(matrix), sizeof(float) * 16);
}

write() [2/2]

void SkBinaryWriteBuffer::write ( const void *  buffer, size_t  bytes  )

inline

Definition at line 103 of file SkWriteBuffer.h.

                                                 {
        fWriter.write(buffer, bytes);
    }

writeBool()

void SkBinaryWriteBuffer::writeBool ( bool  value )

overridevirtual

Implements SkWriteBuffer.

Definition at line 59 of file SkWriteBuffer.cpp.

                                              {
    fWriter.writeBool(value);
}

writeByteArray()

void SkBinaryWriteBuffer::writeByteArray ( const void *  data, size_t  size  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 54 of file SkWriteBuffer.cpp.

                                                                      {
    fWriter.write32(SkToU32(size));
    fWriter.writePad(data, size);
}

writeColor()

void SkBinaryWriteBuffer::writeColor ( SkColor  color )

overridevirtual

Implements SkWriteBuffer.

Definition at line 89 of file SkWriteBuffer.cpp.

                                                  {
    fWriter.write32(color);
}

writeColor4f()

void SkBinaryWriteBuffer::writeColor4f ( const SkColor4f &  color )

overridevirtual

Implements SkWriteBuffer.

Definition at line 98 of file SkWriteBuffer.cpp.

                                                             {
    fWriter.write(&color, sizeof(SkColor4f));
}

writeColor4fArray()

void SkBinaryWriteBuffer::writeColor4fArray ( const SkColor4f *  color, uint32_t  count  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 102 of file SkWriteBuffer.cpp.

                                                                                  {
    fWriter.write32(count);
    fWriter.write(color, count * sizeof(SkColor4f));
}

writeColorArray()

void SkBinaryWriteBuffer::writeColorArray ( const SkColor *  color, uint32_t  count  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 93 of file SkWriteBuffer.cpp.

                                                                              {
    fWriter.write32(count);
    fWriter.write(color, count * sizeof(SkColor));
}

writeFlattenable()

void SkBinaryWriteBuffer::writeFlattenable ( const SkFlattenable *  flattenable )

overridevirtual

Implements SkWriteBuffer.

Definition at line 282 of file SkWriteBuffer.cpp.

                                                                           {
    if (nullptr == flattenable) {
        this->write32(0);
        return;
    }
 
    /*
     *  We can write 1 of 2 versions of the flattenable:
     *
     *  1. index into fFactorySet: This assumes the writer will later resolve the function-ptrs
     *     into strings for its reader. SkPicture does exactly this, by writing a table of names
     *     (matching the indices) up front in its serialized form.
     *
     *  2. string name of the flattenable or index into fFlattenableDict:  We store the string to
     *     allow the reader to specify its own factories after write time. In order to improve
     *     compression, if we have already written the string, we write its index instead.
     */
 
    if (SkFlattenable::Factory factory = flattenable->getFactory(); factory && fFactorySet) {
        this->write32(fFactorySet->add(factory));
    } else {
        const char* name = flattenable->getTypeName();
        SkASSERT(name);
        SkASSERT(0 != strcmp("", name));
 
        if (uint32_t* indexPtr = fFlattenableDict.find(name)) {
            // We will write the index as a 32-bit int.  We want the first byte
            // that we send to be zero - this will act as a sentinel that we
            // have an index (not a string).  This means that we will send the
            // the index shifted left by 8.  The remaining 24-bits should be
            // plenty to store the index.  Note that this strategy depends on
            // being little endian, and type names being non-empty.
            SkASSERT(0 == *indexPtr >> 24);
            this->write32(*indexPtr << 8);
        } else {
            this->writeString(name);
            fFlattenableDict.set(name, fFlattenableDict.count() + 1);
        }
    }
 
    // make room for the size of the flattened object
    (void)fWriter.reserve(sizeof(uint32_t));
    // record the current size, so we can subtract after the object writes.
    size_t offset = fWriter.bytesWritten();
    // now flatten the object
    flattenable->flatten(*this);
    size_t objSize = fWriter.bytesWritten() - offset;
    // record the obj's size
    fWriter.overwriteTAt(offset - sizeof(uint32_t), SkToU32(objSize));
}

writeImage()

void SkBinaryWriteBuffer::writeImage ( const SkImage *  image )

overridevirtual

Implements SkWriteBuffer.

Definition at line 221 of file SkWriteBuffer.cpp.

                                                         {
    uint32_t flags = 0;
    const SkMipmap* mips = as_IB(image)->onPeekMips();
    if (mips) {
        flags |= SkWriteBufferImageFlags::kHasMipmap;
    }
    if (image->alphaType() == kUnpremul_SkAlphaType) {
        flags |= SkWriteBufferImageFlags::kUnpremul;
    }
 
    this->write32(flags);
 
    sk_sp<SkData> data = serialize_image(image, fProcs);
    SkASSERT(data);
    this->writeDataAsByteArray(data.get());
 
    if (flags & SkWriteBufferImageFlags::kHasMipmap) {
        sk_sp<SkData> mipData = serialize_mipmap(mips, fProcs);
        this->writeDataAsByteArray(mipData.get());
    }
}

writeInt()

void SkBinaryWriteBuffer::writeInt ( int32_t  value )

overridevirtual

Implements SkWriteBuffer.

Definition at line 72 of file SkWriteBuffer.cpp.

                                                {
    fWriter.write32(value);
}

writeIntArray()

void SkBinaryWriteBuffer::writeIntArray ( const int32_t *  value, uint32_t  count  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 76 of file SkWriteBuffer.cpp.

                                                                            {
    fWriter.write32(count);
    fWriter.write(value, count * sizeof(int32_t));
}

writeIRect()

void SkBinaryWriteBuffer::writeIRect ( const SkIRect &  rect )

overridevirtual

Implements SkWriteBuffer.

Definition at line 129 of file SkWriteBuffer.cpp.

                                                        {
    fWriter.write(&rect, sizeof(SkIRect));
}

writeMatrix()

void SkBinaryWriteBuffer::writeMatrix ( const SkMatrix &  matrix )

overridevirtual

Implements SkWriteBuffer.

Definition at line 125 of file SkWriteBuffer.cpp.

                                                            {
    fWriter.writeMatrix(matrix);
}

writePad32()

void SkBinaryWriteBuffer::writePad32 ( const void *  buffer, size_t  bytes  )

inlineoverridevirtual

Implements SkWriteBuffer.

Definition at line 106 of file SkWriteBuffer.h.

                                                               {
        fWriter.writePad(buffer, bytes);
    }

writePaint()

void SkBinaryWriteBuffer::writePaint ( const SkPaint &  paint )

overridevirtual

Implements SkWriteBuffer.

Definition at line 270 of file SkWriteBuffer.cpp.

                                                         {
    SkPaintPriv::Flatten(paint, *this);
}

writePath()

void SkBinaryWriteBuffer::writePath ( const SkPath &  path )

overridevirtual

Implements SkWriteBuffer.

Definition at line 145 of file SkWriteBuffer.cpp.

                                                      {
    fWriter.writePath(path);
}

writePoint()

void SkBinaryWriteBuffer::writePoint ( const SkPoint &  point )

overridevirtual

Implements SkWriteBuffer.

Definition at line 107 of file SkWriteBuffer.cpp.

                                                         {
    fWriter.writeScalar(point.fX);
    fWriter.writeScalar(point.fY);
}

writePoint3()

void SkBinaryWriteBuffer::writePoint3 ( const SkPoint3 &  point )

overridevirtual

Implements SkWriteBuffer.

Definition at line 112 of file SkWriteBuffer.cpp.

                                                           {
    this->writePad32(&point, sizeof(SkPoint3));
}

writePointArray()

void SkBinaryWriteBuffer::writePointArray ( const SkPoint *  point, uint32_t  count  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 116 of file SkWriteBuffer.cpp.

                                                                              {
    fWriter.write32(count);
    fWriter.write(point, count * sizeof(SkPoint));
}

writeRect()

void SkBinaryWriteBuffer::writeRect ( const SkRect &  rect )

overridevirtual

Implements SkWriteBuffer.

Definition at line 133 of file SkWriteBuffer.cpp.

                                                      {
    fWriter.writeRect(rect);
}

writeRegion()

void SkBinaryWriteBuffer::writeRegion ( const SkRegion &  region )

overridevirtual

Implements SkWriteBuffer.

Definition at line 137 of file SkWriteBuffer.cpp.

                                                            {
    fWriter.writeRegion(region);
}

writeSampling()

void SkBinaryWriteBuffer::writeSampling ( const SkSamplingOptions &  sampling )

overridevirtual

Implements SkWriteBuffer.

Definition at line 141 of file SkWriteBuffer.cpp.

                                                                         {
    fWriter.writeSampling(sampling);
}

writeScalar()

void SkBinaryWriteBuffer::writeScalar ( SkScalar  value )

overridevirtual

Implements SkWriteBuffer.

Definition at line 63 of file SkWriteBuffer.cpp.

                                                    {
    fWriter.writeScalar(value);
}

writeScalarArray()

void SkBinaryWriteBuffer::writeScalarArray ( const SkScalar *  value, uint32_t  count  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 67 of file SkWriteBuffer.cpp.

                                                                                {
    fWriter.write32(count);
    fWriter.write(value, count * sizeof(SkScalar));
}

writeStream()

size_t SkBinaryWriteBuffer::writeStream ( SkStream *  stream, size_t  length  )

overridevirtual

Implements SkWriteBuffer.

Definition at line 149 of file SkWriteBuffer.cpp.

                                                                       {
    fWriter.write32(SkToU32(length));
    size_t bytesWritten = fWriter.readFromStream(stream, length);
    if (bytesWritten < length) {
        fWriter.reservePad(length - bytesWritten);
    }
    return bytesWritten;
}

writeString()

void SkBinaryWriteBuffer::writeString ( std::string_view  value )

overridevirtual

Implements SkWriteBuffer.

Definition at line 85 of file SkWriteBuffer.cpp.

                                                          {
    fWriter.writeString(value.data(), value.size());
}

writeToMemory()

void SkBinaryWriteBuffer::writeToMemory ( void *  dst ) const

inline

Definition at line 150 of file SkWriteBuffer.h.

{ fWriter.flatten(dst); }

writeToStream()

bool SkBinaryWriteBuffer::writeToStream

(

SkWStream *

stream

)

const

Definition at line 158 of file SkWriteBuffer.cpp.

                                                               {
    return fWriter.writeToStream(stream);
}

writeTypeface()

void SkBinaryWriteBuffer::writeTypeface ( SkTypeface *  typeface )

overridevirtual

Implements SkWriteBuffer.

Definition at line 243 of file SkWriteBuffer.cpp.

                                                       {
    // Write 32 bits (signed)
    //   0 -- empty font
    //  >0 -- index
    //  <0 -- custom (serial procs)
 
    if (obj == nullptr) {
        fWriter.write32(0);
    } else if (fProcs.fTypefaceProc) {
        auto data = fProcs.fTypefaceProc(obj, fProcs.fTypefaceCtx);
        if (data) {
            size_t size = data->size();
            if (!SkTFitsIn<int32_t>(size)) {
                size = 0;               // fall back to default font
            }
            int32_t ssize = SkToS32(size);
            fWriter.write32(-ssize);    // negative to signal custom
            if (size) {
                this->writePad32(data->data(), size);
            }
            return;
        }
        // no data means fall through for std behavior
    }
    fWriter.write32(fTFSet ? fTFSet->add(obj) : 0);
}

writeUInt()

void SkBinaryWriteBuffer::writeUInt ( uint32_t  value )

overridevirtual

Implements SkWriteBuffer.

Definition at line 81 of file SkWriteBuffer.cpp.

                                                  {
    fWriter.write32(value);
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkWriteBuffer.h
• third_party/skia/src/core/SkWriteBuffer.cpp