tools/debugger/DebugLayerManager.cpp - skia - Git at Google

 /*
  * 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 "tools/debugger/DebugLayerManager.h"

 #include "include/core/SkAlphaType.h"
 #include "include/core/SkColorSpace.h"
 #include "include/core/SkColorType.h"
 #include "include/core/SkImage.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkPicture.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkDebug.h"
 #include "src/core/SkTHash.h"
 #include "tools/debugger/DebugCanvas.h"

 #include <cstdint>
 #include <memory>
 #include <unordered_map>
 #include <utility>
 #include <vector>

 void DebugLayerManager::setCommand(int nodeId, int frame, int command) {
     auto* drawEvent = fDraws.find({frame, nodeId});
     if (!drawEvent) {
         SkDebugf(
                 "Could not set command playhead for event {%d, %d}, it is not tracked by"
                 "DebugLayerManager.\n",
                 frame,
                 nodeId);
         return;
     }
     const int count = drawEvent->debugCanvas->getSize();
     drawEvent->command = command < count ? command : count - 1;
     // Invalidate stored images that depended on this combination of node and frame.
     // actually this does all of the events for this nodeId, but close enough.
     auto relevantFrames = listFramesForNode(nodeId);
     for (const auto& f : relevantFrames) {
         fDraws[{f, nodeId}].image = nullptr;
     }
 }

 void DebugLayerManager::storeSkPicture(int nodeId,
                                        int frame,
                                        const sk_sp<SkPicture>& picture,
                                        SkIRect dirty) {
     const LayerKey k = {frame, nodeId};

     // Make debug canvas using bounds from SkPicture. This will be equal to whatever width and
     // height were passed into SkPictureRecorder::beginRecording(w, h) which is the layer bounds.
     const auto& layerBounds = picture->cullRect().roundOut();
     auto debugCanvas = std::make_unique<DebugCanvas>(layerBounds);
     // Must be set or they end up undefined due to cosmic rays, bad luck, etc.
     debugCanvas->setOverdrawViz(false);
     debugCanvas->setDrawGpuOpBounds(false);
     debugCanvas->setClipVizColor(SK_ColorTRANSPARENT);
     // Setting this allows a layer to contain another layer. TODO(nifong): write a test for this.
     debugCanvas->setLayerManagerAndFrame(this, frame);
     // Only draw picture to the debug canvas once.
     debugCanvas->drawPicture(picture);
     int numCommands = debugCanvas->getSize();

     DrawEvent event = {
             frame == 0 || dirty == layerBounds,           // fullRedraw
             nullptr,                                      // image
             std::move(debugCanvas),                       // debugCanvas
             numCommands - 1,                              // command
             {layerBounds.width(), layerBounds.height()},  // layerBounds
     };

     fDraws.set(k, std::move(event));
     keys.push_back(k);
 }

 void DebugLayerManager::drawLayerEventTo(SkSurface* surface, const int nodeId, const int frame) {
     auto& evt = fDraws[{frame, nodeId}];
     evt.debugCanvas->drawTo(surface->getCanvas(), evt.command);
 }

 sk_sp<SkImage> DebugLayerManager::getLayerAsImage(const int nodeId, const int frame) {
   // What is the last frame having an SkPicture for this layer? call it frame N
   // have cached image of it? if so, return it.
   // if not, draw it at frame N by the following method:
   // The picture at frame N could have been a full redraw, or it could have been clipped to a
   // dirty region. In order to know what the layer looked like on this frame, we must draw every
   // picture starting with the last full redraw, up to the last one before the current frame, since
   // any of those previous draws could be showing through.

   // list of frames this node was updated on.
   auto relevantFrames = listFramesForNode(nodeId);
   // find largest one not greater than `frame`.
   uint32_t i = relevantFrames.size()-1;
   while (relevantFrames[i] > frame) { i--; }
   const int frameN = relevantFrames[i];
   // Fetch the draw event
   auto& drawEvent = fDraws[{frameN, nodeId}];
   // if an image of this is cached, return it.
   if (drawEvent.image) {
     return drawEvent.image;
   }
   // when it's not cached, we'll have to render it in an offscreen surface.
   // start at the last full redraw. (pick up counting backwards from above)
   while (i>0 && !(fDraws[{relevantFrames[i], nodeId}].fullRedraw)) { i--; }
   // The correct layer bounds can be obtained from any drawEvent on this layer.
   // the color type and alpha type are chosen here to match wasm-skp-debugger/cpu.js which was
   // chosen to match the capabilities of HTML canvas, which this ultimately has to be drawn into.
   // TODO(nifong): introduce a method of letting the user choose the backend for this.
   auto surface = SkSurfaces::Raster(SkImageInfo::Make(
           drawEvent.layerBounds, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, nullptr));
   // draw everything from the last full redraw up to the current frame.
   // other frames drawn are partial, meaning they were clipped to not completely cover the layer.
   // count back up with i
   for (; i<relevantFrames.size() && relevantFrames[i]<=frameN; i++) {
     drawLayerEventTo(surface.get(), nodeId, relevantFrames[i]);
   }
   drawEvent.image = surface->makeImageSnapshot();
   return drawEvent.image;
 }

 DebugLayerManager::DrawEventSummary DebugLayerManager::event(int nodeId, int frame) const {
   auto* evt = fDraws.find({frame, nodeId});
   if (!evt) { return {}; }
   return {
     true, evt->debugCanvas->getSize(),
     evt->layerBounds.width(), evt->layerBounds.height()
   };
 }

 std::vector<DebugLayerManager::LayerSummary> DebugLayerManager::summarizeLayers(int frame) const {
   // Find the last update on or before `frame` for every node
   // key: nodeId, one entry for every layer
   // value: summary of the layer.
   std::unordered_map<int, LayerSummary> summaryMap;
   for (const auto& key : keys) {
     auto* evt = fDraws.find(key);
     if (!evt) { continue; }
     // -1 as a default value for the last update serves as a way of indicating that this layer
     // is present in the animation, but doesn't have an update less than or equal to `frame`
     int lastUpdate = (key.frame <= frame ? key.frame : -1);

     // do we have an entry for this layer yet? is it later than the one we're looking at?
     auto found = summaryMap.find(key.nodeId);
     if (found != summaryMap.end()) {
       LayerSummary& item = summaryMap[key.nodeId];
       if (lastUpdate > item.frameOfLastUpdate) {
         item.frameOfLastUpdate = key.frame;
         item.fullRedraw = evt->fullRedraw;
       }
     } else {
       // record first entry for this layer
       summaryMap.insert({key.nodeId, {
         key.nodeId, lastUpdate, evt->fullRedraw,
         evt->layerBounds.width(), evt->layerBounds.height()
       }});
     }
   }
   std::vector<LayerSummary> result;
   for (auto it = summaryMap.begin(); it != summaryMap.end(); ++it) {
     result.push_back(it->second);
   }
   return result;
 }

 std::vector<int> DebugLayerManager::listNodesForFrame(int frame) const {
   std::vector<int> result;
   for (const auto& key : keys) {
     if (key.frame == frame) {
       result.push_back(key.nodeId);
     }
   }
   return result;
 }

 std::vector<int> DebugLayerManager::listFramesForNode(int nodeId) const {
   std::vector<int> result;
   for (const auto& key : keys) {
     if (key.nodeId == nodeId) {
       result.push_back(key.frame);
     }
   }
   return result;
 }

 DebugCanvas* DebugLayerManager::getEventDebugCanvas(int nodeId, int frame) {
   auto& evt = fDraws[{frame, nodeId}];
   return evt.debugCanvas.get();
 }

 void DebugLayerManager::setOverdrawViz(bool overdrawViz) {
   for (const auto& key : keys) {
     auto& evt = fDraws[key];
     evt.debugCanvas->setOverdrawViz(overdrawViz);
   }
 }

 void DebugLayerManager::setClipVizColor(SkColor clipVizColor) {
   for (const auto& key : keys) {
     auto& evt = fDraws[key];
     evt.debugCanvas->setClipVizColor(clipVizColor);
   }
 }

 void DebugLayerManager::setDrawGpuOpBounds(bool drawGpuOpBounds) {
   for (const auto& key : keys) {
     auto& evt = fDraws[key];
     evt.debugCanvas->setDrawGpuOpBounds(drawGpuOpBounds);
   }
 }
	/*
	* 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 "tools/debugger/DebugLayerManager.h"

	#include "include/core/SkAlphaType.h"
	#include "include/core/SkColorSpace.h"
	#include "include/core/SkColorType.h"
	#include "include/core/SkImage.h"
	#include "include/core/SkImageInfo.h"
	#include "include/core/SkPicture.h"
	#include "include/core/SkRect.h"
	#include "include/core/SkSurface.h"
	#include "include/core/SkTypes.h"
	#include "include/private/base/SkDebug.h"
	#include "src/core/SkTHash.h"
	#include "tools/debugger/DebugCanvas.h"

	#include <cstdint>
	#include <memory>
	#include <unordered_map>
	#include <utility>
	#include <vector>

	void DebugLayerManager::setCommand(int nodeId, int frame, int command) {
	auto* drawEvent = fDraws.find({frame, nodeId});
	if (!drawEvent) {
	SkDebugf(
	"Could not set command playhead for event {%d, %d}, it is not tracked by"
	"DebugLayerManager.\n",
	frame,
	nodeId);
	return;
	}
	const int count = drawEvent->debugCanvas->getSize();
	drawEvent->command = command < count ? command : count - 1;
	// Invalidate stored images that depended on this combination of node and frame.
	// actually this does all of the events for this nodeId, but close enough.
	auto relevantFrames = listFramesForNode(nodeId);
	for (const auto& f : relevantFrames) {
	fDraws[{f, nodeId}].image = nullptr;
	}
	}

	void DebugLayerManager::storeSkPicture(int nodeId,
	int frame,
	const sk_sp<SkPicture>& picture,
	SkIRect dirty) {
	const LayerKey k = {frame, nodeId};

	// Make debug canvas using bounds from SkPicture. This will be equal to whatever width and
	// height were passed into SkPictureRecorder::beginRecording(w, h) which is the layer bounds.
	const auto& layerBounds = picture->cullRect().roundOut();
	auto debugCanvas = std::make_unique<DebugCanvas>(layerBounds);
	// Must be set or they end up undefined due to cosmic rays, bad luck, etc.
	debugCanvas->setOverdrawViz(false);
	debugCanvas->setDrawGpuOpBounds(false);
	debugCanvas->setClipVizColor(SK_ColorTRANSPARENT);
	// Setting this allows a layer to contain another layer. TODO(nifong): write a test for this.
	debugCanvas->setLayerManagerAndFrame(this, frame);
	// Only draw picture to the debug canvas once.
	debugCanvas->drawPicture(picture);
	int numCommands = debugCanvas->getSize();

	DrawEvent event = {
	frame == 0 \|\| dirty == layerBounds, // fullRedraw
	nullptr, // image
	std::move(debugCanvas), // debugCanvas
	numCommands - 1, // command
	{layerBounds.width(), layerBounds.height()}, // layerBounds
	};

	fDraws.set(k, std::move(event));
	keys.push_back(k);
	}

	void DebugLayerManager::drawLayerEventTo(SkSurface* surface, const int nodeId, const int frame) {
	auto& evt = fDraws[{frame, nodeId}];
	evt.debugCanvas->drawTo(surface->getCanvas(), evt.command);
	}

	sk_sp<SkImage> DebugLayerManager::getLayerAsImage(const int nodeId, const int frame) {
	// What is the last frame having an SkPicture for this layer? call it frame N
	// have cached image of it? if so, return it.
	// if not, draw it at frame N by the following method:
	// The picture at frame N could have been a full redraw, or it could have been clipped to a
	// dirty region. In order to know what the layer looked like on this frame, we must draw every
	// picture starting with the last full redraw, up to the last one before the current frame, since
	// any of those previous draws could be showing through.

	// list of frames this node was updated on.
	auto relevantFrames = listFramesForNode(nodeId);
	// find largest one not greater than `frame`.
	uint32_t i = relevantFrames.size()-1;
	while (relevantFrames[i] > frame) { i--; }
	const int frameN = relevantFrames[i];
	// Fetch the draw event
	auto& drawEvent = fDraws[{frameN, nodeId}];
	// if an image of this is cached, return it.
	if (drawEvent.image) {
	return drawEvent.image;
	}
	// when it's not cached, we'll have to render it in an offscreen surface.
	// start at the last full redraw. (pick up counting backwards from above)
	while (i>0 && !(fDraws[{relevantFrames[i], nodeId}].fullRedraw)) { i--; }
	// The correct layer bounds can be obtained from any drawEvent on this layer.
	// the color type and alpha type are chosen here to match wasm-skp-debugger/cpu.js which was
	// chosen to match the capabilities of HTML canvas, which this ultimately has to be drawn into.
	// TODO(nifong): introduce a method of letting the user choose the backend for this.
	auto surface = SkSurfaces::Raster(SkImageInfo::Make(
	drawEvent.layerBounds, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType, nullptr));
	// draw everything from the last full redraw up to the current frame.
	// other frames drawn are partial, meaning they were clipped to not completely cover the layer.
	// count back up with i
	for (; i<relevantFrames.size() && relevantFrames[i]<=frameN; i++) {
	drawLayerEventTo(surface.get(), nodeId, relevantFrames[i]);
	}
	drawEvent.image = surface->makeImageSnapshot();
	return drawEvent.image;
	}

	DebugLayerManager::DrawEventSummary DebugLayerManager::event(int nodeId, int frame) const {
	auto* evt = fDraws.find({frame, nodeId});
	if (!evt) { return {}; }
	return {
	true, evt->debugCanvas->getSize(),
	evt->layerBounds.width(), evt->layerBounds.height()
	};
	}

	std::vector<DebugLayerManager::LayerSummary> DebugLayerManager::summarizeLayers(int frame) const {
	// Find the last update on or before `frame` for every node
	// key: nodeId, one entry for every layer
	// value: summary of the layer.
	std::unordered_map<int, LayerSummary> summaryMap;
	for (const auto& key : keys) {
	auto* evt = fDraws.find(key);
	if (!evt) { continue; }
	// -1 as a default value for the last update serves as a way of indicating that this layer
	// is present in the animation, but doesn't have an update less than or equal to `frame`
	int lastUpdate = (key.frame <= frame ? key.frame : -1);

	// do we have an entry for this layer yet? is it later than the one we're looking at?
	auto found = summaryMap.find(key.nodeId);
	if (found != summaryMap.end()) {
	LayerSummary& item = summaryMap[key.nodeId];
	if (lastUpdate > item.frameOfLastUpdate) {
	item.frameOfLastUpdate = key.frame;
	item.fullRedraw = evt->fullRedraw;
	}
	} else {
	// record first entry for this layer
	summaryMap.insert({key.nodeId, {
	key.nodeId, lastUpdate, evt->fullRedraw,
	evt->layerBounds.width(), evt->layerBounds.height()
	}});
	}
	}
	std::vector<LayerSummary> result;
	for (auto it = summaryMap.begin(); it != summaryMap.end(); ++it) {
	result.push_back(it->second);
	}
	return result;
	}

	std::vector<int> DebugLayerManager::listNodesForFrame(int frame) const {
	std::vector<int> result;
	for (const auto& key : keys) {
	if (key.frame == frame) {
	result.push_back(key.nodeId);
	}
	}
	return result;
	}

	std::vector<int> DebugLayerManager::listFramesForNode(int nodeId) const {
	std::vector<int> result;
	for (const auto& key : keys) {
	if (key.nodeId == nodeId) {
	result.push_back(key.frame);
	}
	}
	return result;
	}

	DebugCanvas* DebugLayerManager::getEventDebugCanvas(int nodeId, int frame) {
	auto& evt = fDraws[{frame, nodeId}];
	return evt.debugCanvas.get();
	}

	void DebugLayerManager::setOverdrawViz(bool overdrawViz) {
	for (const auto& key : keys) {
	auto& evt = fDraws[key];
	evt.debugCanvas->setOverdrawViz(overdrawViz);
	}
	}

	void DebugLayerManager::setClipVizColor(SkColor clipVizColor) {
	for (const auto& key : keys) {
	auto& evt = fDraws[key];
	evt.debugCanvas->setClipVizColor(clipVizColor);
	}
	}

	void DebugLayerManager::setDrawGpuOpBounds(bool drawGpuOpBounds) {
	for (const auto& key : keys) {
	auto& evt = fDraws[key];
	evt.debugCanvas->setDrawGpuOpBounds(drawGpuOpBounds);
	}
	}