SkMultiPictureDocument Namespace Reference

Functions
SK_API sk_sp< SkDocument >	Make (SkWStream *dst, const SkSerialProcs *=nullptr, std::function< void(const SkPicture *)> onEndPage=nullptr)
SK_API int	ReadPageCount (SkStreamSeekable *src)
SK_API bool	Read (SkStreamSeekable *src, SkDocumentPage *dstArray, int dstArrayCount, const SkDeserialProcs *=nullptr)
bool	ReadPageSizes (SkStreamSeekable *stream, SkDocumentPage *dstArray, int dstArrayCount)

Function Documentation

Make()

sk_sp< SkDocument > SkMultiPictureDocument::Make	(	SkWStream *	dst,
		const SkSerialProcs *	procs = nullptr,
		std::function< void(const SkPicture *)>	onEndPage = nullptr
	)

Writes into a file format that is similar to SkPicture::serialize() Accepts a callback for endPage behavior

Definition at line 150 of file SkMultiPictureDocument.cpp.

                                                                      {
    return sk_make_sp<MultiPictureDocument>(dst, procs, std::move(onEndPage));
}

Read()

bool SkMultiPictureDocument::Read	(	SkStreamSeekable *	src,
		SkDocumentPage *	dstArray,
		int	dstArrayCount,
		const SkDeserialProcs *	procs = nullptr
	)

Read the SkMultiPictureDocument into the provided array of pages. dstArrayCount must equal SkMultiPictureDocumentReadPageCount(). Return false on error.

Definition at line 199 of file SkMultiPictureDocument.cpp.

                                        {
    if (!ReadPageSizes(src, dstArray, dstArrayCount)) {
        return false;
    }
    SkSize joined = {0.0f, 0.0f};
    for (int i = 0; i < dstArrayCount; ++i) {
        joined = SkSize{std::max(joined.width(), dstArray[i].fSize.width()),
                        std::max(joined.height(), dstArray[i].fSize.height())};
    }
 
    auto picture = SkPicture::MakeFromStream(src, procs);
    if (!picture) {
        return false;
    }
 
    PagerCanvas canvas(joined.toCeil(), dstArray, dstArrayCount);
    // Must call playback(), not drawPicture() to reach
    // PagerCanvas::onDrawAnnotation().
    picture->playback(&canvas);
    if (canvas.fIndex != dstArrayCount) {
        SkDEBUGF("Malformed SkMultiPictureDocument: canvas.fIndex=%d dstArrayCount=%d\n",
            canvas.fIndex, dstArrayCount);
    }
    return true;
}

ReadPageCount()

int SkMultiPictureDocument::ReadPageCount

(

SkStreamSeekable *

src

)

Returns the number of pages in the SkMultiPictureDocument.

Definition at line 156 of file SkMultiPictureDocument.cpp.

                                         {
    if (!src) {
        return 0;
    }
    src->seek(0);
    const size_t size = sizeof(kMagic) - 1;
    char buffer[size];
    if (size != src->read(buffer, size) || 0 != memcmp(kMagic, buffer, size)) {
        src = nullptr;
        return 0;
    }
    uint32_t versionNumber;
    if (!src->readU32(&versionNumber) || versionNumber != kVersion) {
        return 0;
    }
    uint32_t pageCount;
    if (!src->readU32(&pageCount) || pageCount > INT_MAX) {
        return 0;
    }
    // leave stream position right here.
    return SkTo<int>(pageCount);
}

ReadPageSizes()

bool SkMultiPictureDocument::ReadPageSizes	(	SkStreamSeekable *	src,
		SkDocumentPage *	dstArray,
		int	dstArrayCount
	)

Additional API allows one to read the array of page-sizes without parsing the entire file. Used by DM.

Definition at line 179 of file SkMultiPictureDocument.cpp.

                                      {
    if (!dstArray || dstArrayCount < 1) {
        return false;
    }
    int pageCount = ReadPageCount(stream);
    if (pageCount < 1 || pageCount != dstArrayCount) {
        return false;
    }
    for (int i = 0; i < pageCount; ++i) {
        SkSize& s = dstArray[i].fSize;
        if (sizeof(s) != stream->read(&s, sizeof(s))) {
            return false;
        }
    }
    // leave stream position right here.
    return true;
}