SkPictureData Class Reference

#include <SkPictureData.h>

Public Member Functions
	SkPictureData (const SkPictureRecord &record, const SkPictInfo &)
void	serialize (SkWStream *, const SkSerialProcs &, SkRefCntSet *, bool textBlobsOnly=false) const
void	flatten (SkWriteBuffer &) const
const SkPictInfo &	info () const
const sk_sp< SkData > &	opData () const
const SkImage *	getImage (SkReadBuffer *reader) const
const SkPath &	getPath (SkReadBuffer *reader) const
const SkPicture *	getPicture (SkReadBuffer *reader) const
SkDrawable *	getDrawable (SkReadBuffer *reader) const
const SkPaint *	optionalPaint (SkReadBuffer *reader) const
const SkPaint &	requiredPaint (SkReadBuffer *reader) const
const SkTextBlob *	getTextBlob (SkReadBuffer *reader) const
const sktext::gpu::Slug *	getSlug (SkReadBuffer *reader) const
const SkVertices *	getVertices (SkReadBuffer *reader) const

Static Public Member Functions
static SkPictureData *	CreateFromStream (SkStream *, const SkPictInfo &, const SkDeserialProcs &, SkTypefacePlayback *, int recursionLimit)
static SkPictureData *	CreateFromBuffer (SkReadBuffer &, const SkPictInfo &)

Protected Member Functions
	SkPictureData (const SkPictInfo &info)
bool	parseStream (SkStream *, const SkDeserialProcs &, SkTypefacePlayback *, int recursionLimit)
bool	parseBuffer (SkReadBuffer &buffer)

Detailed Description

Definition at line 87 of file SkPictureData.h.

Constructor & Destructor Documentation

SkPictureData() [1/2]

SkPictureData::SkPictureData	(	const SkPictureRecord &	record,
		const SkPictInfo &	info
	)

Definition at line 50 of file SkPictureData.cpp.

    : fPictures(record.getPictures())
    , fDrawables(record.getDrawables())
    , fTextBlobs(record.getTextBlobs())
    , fVertices(record.getVertices())
    , fImages(record.getImages())
    , fSlugs(record.getSlugs())
    , fInfo(info) {
 
    fOpData = record.opData();
 
    fPaints  = record.fPaints;
 
    fPaths.reset(record.fPaths.count());
    record.fPaths.foreach([this](const SkPath& path, int n) {
        // These indices are logically 1-based, but we need to serialize them
        // 0-based to keep the deserializing SkPictureData::getPath() working.
        fPaths[n-1] = path;
    });
 
    this->initForPlayback();
}

SkPictureData() [2/2]

SkPictureData::SkPictureData ( const SkPictInfo &  info )

explicitprotected

Definition at line 40 of file SkPictureData.cpp.

    : fInfo(info) {}

Member Function Documentation

CreateFromBuffer()

SkPictureData * SkPictureData::CreateFromBuffer ( SkReadBuffer &  buffer, const SkPictInfo &  info  )

static

Definition at line 534 of file SkPictureData.cpp.

                                                                       {
    std::unique_ptr<SkPictureData> data(new SkPictureData(info));
    buffer.setVersion(info.getVersion());
 
    if (!data->parseBuffer(buffer)) {
        return nullptr;
    }
    return data.release();
}

CreateFromStream()

SkPictureData * SkPictureData::CreateFromStream ( SkStream *  stream, const SkPictInfo &  info, const SkDeserialProcs &  procs, SkTypefacePlayback *  topLevelTFPlayback, int  recursionLimit  )

static

Definition at line 518 of file SkPictureData.cpp.

                                                                   {
    std::unique_ptr<SkPictureData> data(new SkPictureData(info));
    if (!topLevelTFPlayback) {
        topLevelTFPlayback = &data->fTFPlayback;
    }
 
    if (!data->parseStream(stream, procs, topLevelTFPlayback, recursionLimit)) {
        return nullptr;
    }
    return data.release();
}

flatten()

void SkPictureData::flatten

(

SkWriteBuffer &

buffer

)

const

Definition at line 281 of file SkPictureData.cpp.

                                                       {
    write_tag_size(buffer, SK_PICT_READER_TAG, fOpData->size());
    buffer.writeByteArray(fOpData->bytes(), fOpData->size());
 
    if (!fPictures.empty()) {
        write_tag_size(buffer, SK_PICT_PICTURE_TAG, fPictures.size());
        for (const auto& pic : fPictures) {
            SkPicturePriv::Flatten(pic, buffer);
        }
    }
 
    if (!fDrawables.empty()) {
        write_tag_size(buffer, SK_PICT_DRAWABLE_TAG, fDrawables.size());
        for (const auto& draw : fDrawables) {
            buffer.writeFlattenable(draw.get());
        }
    }
 
    // Write this picture playback's data into a writebuffer
    this->flattenToBuffer(buffer, false);
    buffer.write32(SK_PICT_EOF_TAG);
}

getDrawable()

SkDrawable * SkPictureData::getDrawable ( SkReadBuffer *  reader ) const

inline

Definition at line 130 of file SkPictureData.h.

                                                        {
        return read_index_base_1_or_null(reader, fDrawables);
    }

getImage()

const SkImage * SkPictureData::getImage ( SkReadBuffer *  reader ) const

inline

Definition at line 114 of file SkPictureData.h.

                                                        {
        // images are written base-0, unlike paths, pictures, drawables, etc.
        const int index = reader->readInt();
        return reader->validateIndex(index, fImages.size()) ? fImages[index].get() : nullptr;
    }

getPath()

const SkPath & SkPictureData::getPath ( SkReadBuffer *  reader ) const

inline

Definition at line 120 of file SkPictureData.h.

                                                      {
        int index = reader->readInt();
        return reader->validate(index > 0 && index <= fPaths.size()) ?
                fPaths[index - 1] : fEmptyPath;
    }

getPicture()

const SkPicture * SkPictureData::getPicture ( SkReadBuffer *  reader ) const

inline

Definition at line 126 of file SkPictureData.h.

                                                            {
        return read_index_base_1_or_null(reader, fPictures);
    }

getSlug()

const sktext::gpu::Slug * SkPictureData::getSlug ( SkReadBuffer *  reader ) const

inline

Definition at line 145 of file SkPictureData.h.

                                                             {
        return read_index_base_1_or_null(reader, fSlugs);
    }

getTextBlob()

const SkTextBlob * SkPictureData::getTextBlob ( SkReadBuffer *  reader ) const

inline

Definition at line 141 of file SkPictureData.h.

                                                              {
        return read_index_base_1_or_null(reader, fTextBlobs);
    }

getVertices()

const SkVertices * SkPictureData::getVertices ( SkReadBuffer *  reader ) const

inline

Definition at line 149 of file SkPictureData.h.

                                                              {
        return read_index_base_1_or_null(reader, fVertices);
    }

info()

const SkPictInfo & SkPictureData::info ( ) const

inline

Definition at line 101 of file SkPictureData.h.

{ return fInfo; }

opData()

const sk_sp< SkData > & SkPictureData::opData ( ) const

inline

Definition at line 103 of file SkPictureData.h.

{ return fOpData; }

optionalPaint()

const SkPaint * SkPictureData::optionalPaint

(

SkReadBuffer *

reader

)

const

Definition at line 583 of file SkPictureData.cpp.

                                                                      {
    int index = reader->readInt();
    if (index == 0) {
        return nullptr; // recorder wrote a zero for no paint (likely drawimage)
    }
    return reader->validate(index > 0 && index <= fPaints.size()) ?
        &fPaints[index - 1] : nullptr;
}

parseBuffer()

bool SkPictureData::parseBuffer ( SkReadBuffer &  buffer )

protected

Definition at line 565 of file SkPictureData.cpp.

                                                    {
    while (buffer.isValid()) {
        uint32_t tag = buffer.readUInt();
        if (SK_PICT_EOF_TAG == tag) {
            break;
        }
        this->parseBufferTag(buffer, tag, buffer.readUInt());
    }
 
    // Check that we encountered required tags
    if (!buffer.validate(this->opData() != nullptr)) {
        // If we didn't build any opData, we are invalid. Even an EmptyPicture allocates the
        // SkData for the ops (though its length may be zero).
        return false;
    }
    return true;
}

parseStream()

bool SkPictureData::parseStream ( SkStream *  stream, const SkDeserialProcs &  procs, SkTypefacePlayback *  topLevelTFPlayback, int  recursionLimit  )

protected

Definition at line 545 of file SkPictureData.cpp.

                                                    {
    for (;;) {
        uint32_t tag;
        if (!stream->readU32(&tag)) { return false; }
        if (SK_PICT_EOF_TAG == tag) {
            break;
        }
 
        uint32_t size;
        if (!stream->readU32(&size)) { return false; }
        if (!this->parseStreamTag(stream, tag, size, procs, topLevelTFPlayback, recursionLimit)) {
            return false; // we're invalid
        }
    }
    return true;
}

requiredPaint()

const SkPaint & SkPictureData::requiredPaint

(

SkReadBuffer *

reader

)

const

Definition at line 592 of file SkPictureData.cpp.

                                                                      {
    const SkPaint* paint = this->optionalPaint(reader);
    if (reader->validate(paint != nullptr)) {
        return *paint;
    }
    static const SkPaint& stub = *(new SkPaint);
    return stub;
}

serialize()

void SkPictureData::serialize	(	SkWStream *	stream,
		const SkSerialProcs &	procs,
		SkRefCntSet *	topLevelTypeFaceSet,
		bool	textBlobsOnly = false
	)		const

Definition at line 227 of file SkPictureData.cpp.

                                                                                          {
    // This can happen at pretty much any time, so might as well do it first.
    write_tag_size(stream, SK_PICT_READER_TAG, fOpData->size());
    stream->write(fOpData->bytes(), fOpData->size());
 
    // We serialize all typefaces into the typeface section of the top-level picture.
    SkRefCntSet localTypefaceSet;
    SkRefCntSet* typefaceSet = topLevelTypeFaceSet ? topLevelTypeFaceSet : &localTypefaceSet;
 
    // We delay serializing the bulk of our data until after we've serialized
    // factories and typefaces by first serializing to an in-memory write buffer.
    SkFactorySet factSet;  // buffer refs factSet, so factSet must come first.
    SkBinaryWriteBuffer buffer(skip_typeface_proc(procs));
    buffer.setFactoryRecorder(sk_ref_sp(&factSet));
    buffer.setTypefaceRecorder(sk_ref_sp(typefaceSet));
    this->flattenToBuffer(buffer, textBlobsOnly);
 
    // Pretend to serialize our sub-pictures for the side effect of filling typefaceSet
    // with typefaces from sub-pictures.
    struct DevNull: public SkWStream {
        DevNull() : fBytesWritten(0) {}
        size_t fBytesWritten;
        bool write(const void*, size_t size) override { fBytesWritten += size; return true; }
        size_t bytesWritten() const override { return fBytesWritten; }
    } devnull;
    for (const auto& pic : fPictures) {
        pic->serialize(&devnull, nullptr, typefaceSet, /*textBlobsOnly=*/ true);
    }
    if (textBlobsOnly) { return; } // return early from fake serialize
 
    // We need to write factories before we write the buffer.
    // We need to write typefaces before we write the buffer or any sub-picture.
    WriteFactories(stream, factSet);
    // Pass the original typefaceproc (if any) now that we're ready to actually serialize the
    // typefaces. We skipped this proc before, when we were serializing paints, so that the
    // paints would just write indices into our typeface set.
    WriteTypefaces(stream, *typefaceSet, procs);
 
    // Write the buffer.
    write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
    buffer.writeToStream(stream);
 
    // Write sub-pictures by calling serialize again.
    if (!fPictures.empty()) {
        write_tag_size(stream, SK_PICT_PICTURE_TAG, fPictures.size());
        for (const auto& pic : fPictures) {
            pic->serialize(stream, &procs, typefaceSet, /*textBlobsOnly=*/ false);
        }
    }
 
    stream->write32(SK_PICT_EOF_TAG);
}

---

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

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