MSKPPlayer Class Reference

#include <MSKPPlayer.h>

Classes
struct	Cmd
class	CmdRecordCanvas
struct	DrawLayerCmd
struct	PicCmd

Public Member Functions
	~MSKPPlayer ()
SkISize	maxDimensions () const
int	numFrames () const
SkISize	frameDimensions (int i) const
bool	playFrame (SkCanvas *canvas, int i)
void	resetLayers ()
void	rewindLayers ()
void	allocateLayers (SkCanvas *)
std::vector< int >	layerIDs (int frame=-1) const
sk_sp< SkImage >	layerSnapshot (int layerID) const

Static Public Member Functions
static std::unique_ptr< MSKPPlayer >	Make (SkStreamSeekable *stream)

Detailed Description

Plays frames/pages of a MSKP to a canvas. This class uses the term "frame" as though the MSKP contains an animation, though it could indeed contain pages of a static document.

Definition at line 27 of file MSKPPlayer.h.

Constructor & Destructor Documentation

~MSKPPlayer()

MSKPPlayer::~MSKPPlayer ( )

default

Member Function Documentation

allocateLayers()

void MSKPPlayer::allocateLayers

(

SkCanvas *

canvas

)

Creates backing stores for any offscreen layers using the passed canvas's makeSurface(). Existing layers that match the canvas's recording context are not reallocated or rewound.

Definition at line 467 of file MSKPPlayer.cpp.

                                                {
    // Iterate over layers not states as states are lazily created in playback but here we want to
    // create any that don't already exist.
    for (auto& [id, layer] : fOffscreenLayers) {
        LayerState& state = fOffscreenLayerStates[id];
        if (!state.fSurface || state.fSurface->recordingContext() != canvas->recordingContext()) {
            state.fCurrCmd = -1;
            state.fSurface = MakeSurfaceForLayer(fOffscreenLayers[id], canvas);
        }
    }
}

frameDimensions()

SkISize MSKPPlayer::frameDimensions

(

int

i

)

const

Size of an individual frame.

Definition at line 417 of file MSKPPlayer.cpp.

                                               {
    if (i < 0 || i >= this->numFrames()) {
        return {-1, -1};
    }
    return fRootLayers[i].fDimensions;
}

layerIDs()

std::vector< int > MSKPPlayer::layerIDs

(

int

frame = -1

)

const

A set of IDs of offscreen layers in no particular order. If frame value >= 0 is specified then the layer set is filtered to layers used by that frame (or empty if >= numFrames). If < 0 then gathers all the layers across all frames.

Definition at line 479 of file MSKPPlayer.cpp.

                                                   {
    std::vector<int> result;
    if (frame < 0) {
        result.reserve(fOffscreenLayers.size());
        for (auto& [id, _] : fOffscreenLayers) {
            result.push_back(id);
        }
        return result;
    }
    if (frame < static_cast<int>(fRootLayers.size())) {
        this->collectReferencedLayers(fRootLayers[frame], &result);
    }
    return result;
}

layerSnapshot()

sk_sp< SkImage > MSKPPlayer::layerSnapshot

(

int

layerID

)

const

Gets the contents of an offscreen layer. It's contents will depend on current playback state (playFrame(), updateFrameLayers(), resetLayers()). If the layer currently has no backing store because it hasn't been drawn or resetLayers() was called then this will return nullptr. Layer contents are not affected by rewindLayers() as that simply lazily redraws the frame contents the next time it is required by playFrame*() or updateFrameLayers().

Definition at line 494 of file MSKPPlayer.cpp.

                                                          {
    auto iter = fOffscreenLayerStates.find(layerID);
    if (iter == fOffscreenLayerStates.end() || !iter->second.fSurface) {
        return nullptr;
    }
    return iter->second.fSurface->makeImageSnapshot();
}

Make()

std::unique_ptr< MSKPPlayer > MSKPPlayer::Make ( SkStreamSeekable *  stream )

static

Make a player from a MSKP stream, or null if stream can't be read as MSKP.

Definition at line 386 of file MSKPPlayer.cpp.

                                                                   {
    auto deserialContext = std::make_unique<SkSharingDeserialContext>();
    SkDeserialProcs procs;
    procs.fImageProc = SkSharingDeserialContext::deserializeImage;
    procs.fImageCtx = deserialContext.get();
 
    int pageCount = SkMultiPictureDocument::ReadPageCount(stream);
    if (!pageCount) {
        return nullptr;
    }
    std::vector<SkDocumentPage> pages(pageCount);
    if (!SkMultiPictureDocument::Read(stream, pages.data(), pageCount, &procs)) {
        return nullptr;
    }
    std::unique_ptr<MSKPPlayer> result(new MSKPPlayer);
    result->fRootLayers.reserve(pages.size());
    for (const auto& page : pages) {
        SkISize dims = {SkScalarCeilToInt(page.fSize.width()),
                        SkScalarCeilToInt(page.fSize.height())};
        result->fRootLayers.emplace_back();
        result->fRootLayers.back().fDimensions = dims;
        result->fMaxDimensions.fWidth  = std::max(dims.width() , result->fMaxDimensions.width() );
        result->fMaxDimensions.fHeight = std::max(dims.height(), result->fMaxDimensions.height());
        CmdRecordCanvas sc(&result->fRootLayers.back(), &result->fOffscreenLayers);
        page.fPicture->playback(&sc);
    }
    return result;
}

maxDimensions()

SkISize MSKPPlayer::maxDimensions ( ) const

inline

Maximum width and height across all frames.

Definition at line 35 of file MSKPPlayer.h.

{ return fMaxDimensions; }

numFrames()

int MSKPPlayer::numFrames ( ) const

inline

Total number of frames.

Definition at line 38 of file MSKPPlayer.h.

{ return static_cast<int>(fRootLayers.size()); }

playFrame()

bool MSKPPlayer::playFrame	(	SkCanvas *	canvas,
		int	i
	)

Plays a frame into the passed canvas. Frames can be randomly accessed. Offscreen layers are incrementally updated from their current state to the state required for the frame (redrawing from scratch if their current state is ahead of the passed frame index).

Definition at line 424 of file MSKPPlayer.cpp.

                                                  {
    if (i < 0 || i >= this->numFrames()) {
        return false;
    }
 
    // Find the first offscreen layer that has a valid surface. If it's recording context
    // differs from the passed canvas's then reset all the layers. Playback will
    // automatically allocate new surfaces for offscreen layers as they're encountered.
    for (const auto& ols : fOffscreenLayerStates) {
        const LayerState& state = ols.second;
        if (state.fSurface) {
            if (state.fSurface->recordingContext() != canvas->recordingContext()) {
                this->resetLayers();
            }
            break;
        }
    }
 
    // Replay all the commands for this frame to the caller's canvas.
    const LayerCmds& layer = fRootLayers[i];
    for (const auto& cmd : layer.fCmds) {
        cmd->draw(canvas, fOffscreenLayers, &fOffscreenLayerStates);
    }
    return true;
}

resetLayers()

void MSKPPlayer::resetLayers

(

)

Destroys any cached offscreen layers.

Definition at line 459 of file MSKPPlayer.cpp.

{ fOffscreenLayerStates.clear(); }

rewindLayers()

void MSKPPlayer::rewindLayers

(

)

Forces all offscreen layers to re-render the next time they're required for a frame but preserves the backing stores for them if already allocated.

Definition at line 461 of file MSKPPlayer.cpp.

                              {
    for (auto& [id, state] : fOffscreenLayerStates) {
        state.fCurrCmd = -1;
    }
}

---

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

• third_party/skia/tools/MSKPPlayer.h
• third_party/skia/tools/MSKPPlayer.cpp