blob: c9c1a02078f60ef9f4e5c2e9cf8b884b262c9cb2 [file] [log] [blame]
* Copyright 2019 Google Inc.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include "include/core/SkColor.h"
#include "include/core/SkImage.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "src/core/SkTHash.h"
#include "tools/debugger/DebugCanvas.h"
#include <memory>
#include <vector>
class SkCanvas;
class SkJSONWriter;
class SkPicture;
class SkSurface;
class UrlDataManager;
struct SkIRect;
// A class to assist in playing back and debugging an mskp file containing offscreen layer commands.
// Holds SkPictures necessary to draw layers in one or more DebugCanvases. During
// recording of the mskp file on Android, each layer had a RenderNode id, which is recorded with
// the layer's draw commands.
// Creates one surface (cpu only for now) for each layer, and renders
// pictures to it up to the requested command using a DebugCanvas.
// Animations are expected to, but may not always use a layer on more than frame.
// the layer may be drawn to more than once, and each different draw is saved for reconstructing the
// layer as it was on any frame. Draws may be partial, meaning their commands were clipped to not
// cover the entire layer.
// Clients may ask for a rendering of a given layer by its RenderNode id and frame, and
// this class will return a rendering of how it looked on that frame.
// returning an SkImage snapshot of the internally managed surface.
class DebugLayerManager {
DebugLayerManager() {}
// Store an SkPicture under a given nodeId (and under the currently set frame number)
// `dirty` is the recorded rect that was used to call androidFramework_setDeviceClipRestriction
// when the layer was drawn.
void storeSkPicture(int nodeId, int frame, const sk_sp<SkPicture>& picture, SkIRect dirty);
// Set's the command playback head for a given picture/draw event.
void setCommand(int nodeId, int frame, int command);
void drawLayerEventTo(SkSurface*, const int nodeId, const int frame);
// getLayerAsImage draws the given layer as it would have looked on frame and returns an image.
// Though each picture can be played back in as many ways as there are commands, we will let
// that be determined by the user who sets an independent playhead for each draw event, tracked
// here, so it stays how they left it.
// For example: Say we are drawing a layer at frame 10.
// Frame 0: Layer was completely redrawn. By default we draw it to its last command. We always
// save the result by (nodeId, frame)
// Frame 5: Layer was partially redrawn, and the user has inspected this draw event, leaving
// its command playhead at command 50/100. We have drew this at the time and save how
// the result looked (all of the commands at frame 0, then half of the commands in the
// partial draw at frame 5)
// Frame 10: Another partial redraw, un-altered, drawn on top of the result from frame 5. We
// return this as the image of how the layer should look on frame 10
// Frame 15: A full redraw
// If the user then comes along and moves the command playhead of the picture at frame 0,
// we invalidate the stored images for 0, 5, and 10, but we can leave 15 alone if we have it.
// Which leaves us with one less degree of freedom to think about when implementing this
// function: We can assume there is only one way to play back a given picture. :)
// The reason the public version of this function doesn't let you specify the frame, is that
// I expect DebugCanvas to call it, which doesn't know which frame it's rendering. The code in
// debugger_bindings.cpp does know, which it why I'm having it set the frame via setFrame(int)
sk_sp<SkImage> getLayerAsImage(const int nodeId, const int frame);
// Flat because it's meant to be bindable by emscripten and returned to the javascript side
struct DrawEventSummary {
// true when the drawEvent represents a valid result.
bool found = false;
int commandCount;
int layerWidth;
int layerHeight;
// return the summary of a single event
DrawEventSummary event(int nodeId, int frame) const;
struct LayerSummary {
int nodeId;
// Last frame less than or equal to the given frame which has an update for this layer
// -1 if the layer has no updates satisfying that constraint.
int frameOfLastUpdate;
// Whether the last update was a full redraw.
bool fullRedraw;
int layerWidth;
int layerHeight;
// Return a list summarizing all layers, with info relevant to the current frame.
std::vector<LayerSummary> summarizeLayers(int frame) const;
// Return the list of node ids which have DrawEvents on the given frame
std::vector<int> listNodesForFrame(int frame) const;
// Return the list of frames on which the given node had DrawEvents.
std::vector<int> listFramesForNode(int nodeId) const;
// asks the DebugCanvas of the indicated draw event to serialize it's commands as JSON.
void toJSON(SkJSONWriter&, UrlDataManager&, SkCanvas*, int nodeId, int frame);
// return a pointer to the debugcanvas of a given draw event.
DebugCanvas* getEventDebugCanvas(int nodeid, int frame);
// forwards the provided setting to all debugcanvases.
void setOverdrawViz(bool overdrawViz);
void setClipVizColor(SkColor clipVizColor);
void setDrawGpuOpBounds(bool drawGpuOpBounds);
struct LayerKey{
int frame; // frame of animation on which this event was recorded.
int nodeId; // the render node id of the layer which was drawn to.
bool operator==(const LayerKey& b) const {
return this->frame==b.frame && this->nodeId==b.nodeId;
// return list of keys that identify layer update events
const std::vector<DebugLayerManager::LayerKey>& getKeys() const { return keys; }
// This class is basically a map from (frame, node) to draw-event
// during recording, at the beginning of any frame, one or more layers could have been drawn on.
// every draw event was recorded, and when reading the mskp file they are stored and organized
// here.
struct DrawEvent {
// true the pic's clip equals the layer bounds.
bool fullRedraw;
// the saved result of how the layer looks on this frame.
// null if we don't have it.
sk_sp<SkImage> image;
// A debug canvas used for drawing this picture.
// the SkPicture itself isn't saved, since it's in the DebugCanvas.
std::unique_ptr<DebugCanvas> debugCanvas;
// the command index where the debugCanvas was left off.
int command;
// the size of the layer this drew into. redundant between multiple DrawEvents on the same
// layer but helpful.
SkISize layerBounds;
skia_private::THashMap<LayerKey, DrawEvent> fDraws;
// The list of all keys in the map above (it has no keys() method)
std::vector<LayerKey> keys;