AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
fb485f1229
skia2/tools/MSKPPlayer.cpp
Brian Osman 68556bc798 Move canvas helper structs to header 
This is necessary cleanup before changing the type of the matrix and
clip stack. That work has landed and reverted several times, so landing
this piece separately, first.

Change-Id: I147e4cc4260fa5e07a0712503f879da120f8466a
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/435278
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Brian Osman <brianosman@google.com>
2021-08-10 17:53:16 +00:00

513 lines
20 KiB
C++
Raw Blame History

/*
* Copyright 2021 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "tools/MSKPPlayer.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkCanvasVirtualEnforcer.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GrDirectContext.h"
#include "include/private/SkTArray.h"
#include "include/utils/SkNoDrawCanvas.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkTLazy.h"
#include "src/utils/SkMultiPictureDocument.h"
#include "tools/SkSharingProc.h"
///////////////////////////////////////////////////////////////////////////////
// Base Cmd struct.
struct MSKPPlayer::Cmd {
virtual ~Cmd() = default;
virtual bool isFullRedraw(SkCanvas*) const = 0;
virtual void draw(SkCanvas* canvas, const LayerMap&, LayerStateMap*) const = 0;
// If this command draws another layer, return it's ID. Otherwise, -1.
virtual int layerID() const { return -1; }
};
// Draws a SkPicture.
struct MSKPPlayer::PicCmd : Cmd {
sk_sp<SkPicture> fContent;
SkIRect fClipRect = SkIRect::MakeEmpty(); // clip for picture (no clip if empty).
bool isFullRedraw(SkCanvas* canvas) const override {
if (fClipRect.isEmpty()) {
return false;
}
return fClipRect.contains(SkIRect::MakeSize(canvas->getBaseLayerSize()));
}
void draw(SkCanvas* canvas, const LayerMap&, LayerStateMap*) const override {
if (!fClipRect.isEmpty()) {
canvas->save();
canvas->clipIRect(fClipRect);
}
canvas->drawPicture(fContent.get());
if (!fClipRect.isEmpty()) {
canvas->restore();
}
}
};
// Draws another layer. Stores the ID of the layer to draw and what command index on that
// layer should be current when the layer is drawn. The layer contents are updated to the
// stored command index before the layer is drawn.
struct MSKPPlayer::DrawLayerCmd : Cmd {
int fLayerId;
size_t fLayerCmdCnt;
SkRect fSrcRect;
SkRect fDstRect;
SkSamplingOptions fSampling;
SkCanvas::SrcRectConstraint fConstraint;
SkTLazy<SkPaint> fPaint;
bool isFullRedraw(SkCanvas* canvas) const override { return false; }
void draw(SkCanvas* canvas, const LayerMap&, LayerStateMap*) const override;
int layerID() const override { return fLayerId; }
};
void MSKPPlayer::DrawLayerCmd::draw(SkCanvas* canvas,
const LayerMap& layerMap,
LayerStateMap* layerStateMap) const {
const LayerCmds& layer = layerMap.at(fLayerId);
LayerState* layerState = &(*layerStateMap)[fLayerId];
if (!layerState->fSurface) {
layerState->fCurrCmd = 0;
layerState->fSurface = MSKPPlayer::MakeSurfaceForLayer(layer, canvas);
if (!layerState->fSurface) {
SkDebugf("Couldn't create surface for layer");
return;
}
}
size_t cmd = layerState->fCurrCmd;
if (cmd > fLayerCmdCnt) {
// If the layer contains contents from later commands then replay from the beginning.
cmd = 0;
}
SkCanvas* layerCanvas = layerState->fSurface->getCanvas();
// Check if there is a full redraw between cmd and fLayerCmdCnt and if so jump to it and ensure
// we clear the canvas if starting from a full redraw.
for (size_t checkCmd = fLayerCmdCnt - 1; checkCmd > cmd; --checkCmd) {
if (layer.fCmds[checkCmd]->isFullRedraw(layerCanvas)) {
cmd = checkCmd;
break;
}
}
for (; cmd < fLayerCmdCnt; ++cmd) {
if (cmd == 0 || layer.fCmds[cmd]->isFullRedraw(layerCanvas)) {
layerState->fSurface->getCanvas()->clear(SK_ColorTRANSPARENT);
}
layer.fCmds[cmd]->draw(layerCanvas, layerMap, layerStateMap);
}
layerState->fCurrCmd = fLayerCmdCnt;
const SkPaint* paint = fPaint.isValid() ? fPaint.get() : nullptr;
canvas->drawImageRect(layerState->fSurface->makeImageSnapshot(),
fSrcRect,
fDstRect,
fSampling,
paint,
fConstraint);
}
///////////////////////////////////////////////////////////////////////////////
class MSKPPlayer::CmdRecordCanvas : public SkCanvasVirtualEnforcer<SkCanvas> {
public:
CmdRecordCanvas(LayerCmds* dst, LayerMap* offscreenLayers, const SkIRect* clipRect = nullptr)
: fDst(dst), fOffscreenLayers(offscreenLayers) {
if (clipRect) {
fClipRect = *clipRect;
}
fRecorder.beginRecording(SkRect::Make(dst->fDimensions));
}
~CmdRecordCanvas() override { this->recordPicCmd(); }
protected:
void onDrawPaint(const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawPaint(paint);
}
void onDrawBehind(const SkPaint& paint) override {
SkCanvasPriv::DrawBehind(fRecorder.getRecordingCanvas(), paint);
}
void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawRect(rect, paint);
}
void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawRRect(rrect, paint);
}
void onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawDRRect(outer, inner, paint);
}
void onDrawOval(const SkRect& rect, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawOval(rect, paint);
}
void onDrawArc(const SkRect& rect,
SkScalar startAngle,
SkScalar sweepAngle,
bool useCenter,
const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawArc(rect, startAngle, sweepAngle, useCenter, paint);
}
void onDrawPath(const SkPath& path, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawPath(path, paint);
}
void onDrawRegion(const SkRegion& region, const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawRegion(region, paint);
}
void onDrawTextBlob(const SkTextBlob* blob,
SkScalar x,
SkScalar y,
const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawTextBlob(blob, x, y, paint);
}
void onDrawPatch(const SkPoint cubics[12],
const SkColor colors[4],
const SkPoint texCoords[4],
SkBlendMode mode,
const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawPatch(cubics, colors, texCoords, mode, paint);
}
void onDrawPoints(SkCanvas::PointMode mode,
size_t count,
const SkPoint pts[],
const SkPaint& paint) override {
fRecorder.getRecordingCanvas()->drawPoints(mode, count, pts, paint);
}
void onDrawImage2(const SkImage* image,
SkScalar dx,
SkScalar dy,
const SkSamplingOptions& sampling,
const SkPaint* paint) override {
fRecorder.getRecordingCanvas()->drawImage(image, dx, dy, sampling, paint);
}
void onDrawImageRect2(const SkImage* image,
const SkRect& src,
const SkRect& dst,
const SkSamplingOptions& sampling,
const SkPaint* paint,
SrcRectConstraint constraint) override {
if (fNextDrawImageFromLayerID != -1) {
this->recordPicCmd();
auto drawLayer = std::make_unique<DrawLayerCmd>();
drawLayer->fLayerId = fNextDrawImageFromLayerID;
drawLayer->fLayerCmdCnt = fOffscreenLayers->at(fNextDrawImageFromLayerID).fCmds.size();
drawLayer->fSrcRect = src;
drawLayer->fDstRect = dst;
drawLayer->fSampling = sampling;
drawLayer->fConstraint = constraint;
if (paint) {
drawLayer->fPaint.init(*paint);
}
fDst->fCmds.push_back(std::move(drawLayer));
fNextDrawImageFromLayerID = -1;
return;
}
fRecorder.getRecordingCanvas()->drawImageRect(image, src, dst, sampling, paint, constraint);
}
void onDrawImageLattice2(const SkImage* image,
const Lattice& lattice,
const SkRect& dst,
SkFilterMode mode,
const SkPaint* paint) override {
fRecorder.getRecordingCanvas()->drawImageLattice(image, lattice, dst, mode, paint);
}
void onDrawAtlas2(const SkImage* image,
const SkRSXform rsxForms[],
const SkRect src[],
const SkColor colors[],
int count,
SkBlendMode mode,
const SkSamplingOptions& sampling,
const SkRect* cull,
const SkPaint* paint) override {
fRecorder.getRecordingCanvas()->drawAtlas(image,
rsxForms,
src,
colors,
count,
mode,
sampling,
cull,
paint);
}
void onDrawEdgeAAImageSet2(const ImageSetEntry imageSet[],
int count,
const SkPoint dstClips[],
const SkMatrix preViewMatrices[],
const SkSamplingOptions& sampling,
const SkPaint* paint,
SrcRectConstraint constraint) override {
fRecorder.getRecordingCanvas()->experimental_DrawEdgeAAImageSet(imageSet,
count,
dstClips,
preViewMatrices,
sampling,
paint,
constraint);
}
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
void onDrawEdgeAAQuad(const SkRect& rect,
const SkPoint clip[4],
SkCanvas::QuadAAFlags aaFlags,
const SkColor4f& color,
SkBlendMode mode) override {}
#else
void onDrawEdgeAAQuad(const SkRect& rect,
const SkPoint clip[4],
SkCanvas::QuadAAFlags aaFlags,
const SkColor4f& color,
SkBlendMode mode) override {
fRecorder.getRecordingCanvas()->experimental_DrawEdgeAAQuad(rect,
clip,
aaFlags,
color,
mode);
}
#endif
void onDrawAnnotation(const SkRect& rect, const char key[], SkData* value) override {
static constexpr char kOffscreenLayerDraw[] = "OffscreenLayerDraw";
static constexpr char kSurfaceID[] = "SurfaceID";
SkTArray<SkString> tokens;
SkStrSplit(key, "|", kStrict_SkStrSplitMode, &tokens);
if (tokens.size() == 2) {
if (tokens[0].equals(kOffscreenLayerDraw)) {
// Indicates that the next drawPicture command contains the SkPicture to render
// to the layer identified by the ID. 'rect' indicates the dirty area to update
// (and indicates the layer size if this command is introducing a new layer id).
fNextDrawPictureToLayerID = std::stoi(tokens[1].c_str());
fNextDrawPictureToLayerClipRect = rect.roundOut();
if (fOffscreenLayers->find(fNextDrawPictureToLayerID) == fOffscreenLayers->end()) {
SkASSERT(fNextDrawPictureToLayerClipRect.left() == 0 &&
fNextDrawPictureToLayerClipRect.top() == 0);
(*fOffscreenLayers)[fNextDrawPictureToLayerID].fDimensions =
fNextDrawPictureToLayerClipRect.size();
}
// The next draw picture will notice that fNextDrawPictureToLayerID is set and
// redirect the picture to the offscreen layer.
return;
} else if (tokens[0].equals(kSurfaceID)) {
// Indicates that the following drawImageRect should draw an offscreen layer
// to this layer.
fNextDrawImageFromLayerID = std::stoi(tokens[1].c_str());
return;
}
}
}
void onDrawShadowRec(const SkPath& path, const SkDrawShadowRec& rec) override {
fRecorder.getRecordingCanvas()->private_draw_shadow_rec(path, rec);
}
void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override {
fRecorder.getRecordingCanvas()->drawDrawable(drawable, matrix);
}
void onDrawPicture(const SkPicture* picture,
const SkMatrix* matrix,
const SkPaint* paint) override {
if (fNextDrawPictureToLayerID != -1) {
SkASSERT(!matrix);
SkASSERT(!paint);
LayerCmds* layer = &fOffscreenLayers->at(fNextDrawPictureToLayerID);
CmdRecordCanvas sc(layer, fOffscreenLayers, &fNextDrawPictureToLayerClipRect);
picture->playback(&sc);
fNextDrawPictureToLayerID = -1;
fNextDrawPictureToLayerClipRect = SkIRect::MakeEmpty();
return;
}
if (paint) {
this->saveLayer(nullptr, paint);
}
if (matrix) {
this->save();
this->concat(*matrix);
}
picture->playback(this);
if (matrix) {
this->restore();
}
if (paint) {
this->restore();
}
fRecorder.getRecordingCanvas()->drawPicture(picture, matrix, paint);
}
private:
void recordPicCmd() {
auto cmd = std::make_unique<PicCmd>();
cmd->fContent = fRecorder.finishRecordingAsPicture();
cmd->fClipRect = fClipRect;
if (cmd->fContent) {
fDst->fCmds.push_back(std::move(cmd));
}
// Set up to accumulate again.
fRecorder.beginRecording(SkRect::Make(fDst->fDimensions));
}
SkPictureRecorder fRecorder; // accumulates draws until we draw an offscreen into this layer.
LayerCmds* fDst = nullptr;
SkIRect fClipRect = SkIRect::MakeEmpty();
int fNextDrawPictureToLayerID = -1;
SkIRect fNextDrawPictureToLayerClipRect = SkIRect::MakeEmpty();
int fNextDrawImageFromLayerID = -1;
LayerMap* fOffscreenLayers = nullptr;
};
///////////////////////////////////////////////////////////////////////////////
std::unique_ptr<MSKPPlayer> MSKPPlayer::Make(SkStreamSeekable* stream) {
auto deserialContext = std::make_unique<SkSharingDeserialContext>();
SkDeserialProcs procs;
procs.fImageProc = SkSharingDeserialContext::deserializeImage;
procs.fImageCtx = deserialContext.get();
int pageCount = SkMultiPictureDocumentReadPageCount(stream);
if (!pageCount) {
return nullptr;
}
std::vector<SkDocumentPage> pages(pageCount);
if (!SkMultiPictureDocumentRead(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;
}
MSKPPlayer::~MSKPPlayer() = default;
SkISize MSKPPlayer::frameDimensions(int i) const {
if (i < 0 || i >= this->numFrames()) {
return {-1, -1};
}
return fRootLayers[i].fDimensions;
}
bool MSKPPlayer::playFrame(SkCanvas* canvas, int i) {
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;
}
sk_sp<SkSurface> MSKPPlayer::MakeSurfaceForLayer(const LayerCmds& layer, SkCanvas* rootCanvas) {
// Assume layer has same surface props and info as this (mskp doesn't currently record this
// data).
SkSurfaceProps props;
rootCanvas->getProps(&props);
return rootCanvas->makeSurface(rootCanvas->imageInfo().makeDimensions(layer.fDimensions),
&props);
}
void MSKPPlayer::resetLayers() { fOffscreenLayerStates.clear(); }
void MSKPPlayer::rewindLayers() {
for (auto& [id, state] : fOffscreenLayerStates) {
state.fCurrCmd = -1;
}
}
void MSKPPlayer::allocateLayers(SkCanvas* canvas) {
// 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);
}
}
}
std::vector<int> MSKPPlayer::layerIDs(int frame) const {
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;
}
sk_sp<SkImage> MSKPPlayer::layerSnapshot(int layerID) const {
auto iter = fOffscreenLayerStates.find(layerID);
if (iter == fOffscreenLayerStates.end() || !iter->second.fSurface) {
return nullptr;
}
return iter->second.fSurface->makeImageSnapshot();
}
void MSKPPlayer::collectReferencedLayers(const LayerCmds& layer, std::vector<int>* out) const {
for (const auto& cmd : layer.fCmds) {
if (int id = cmd->layerID(); id >= 0) {
// Linear, but we'd need to have a lot of layers to actually care.
if (std::find(out->begin(), out->end(), id) == out->end()) {
out->push_back(id);
auto iter = fOffscreenLayers.find(id);
SkASSERT(iter != fOffscreenLayers.end());
this->collectReferencedLayers(iter->second, out);
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink