libs/hwui/pipeline/skia/SkiaPipeline.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "SkiaPipeline.h"

 #include <SkImageEncoder.h>
 #include <SkImagePriv.h>
 #include <SkOverdrawCanvas.h>
 #include <SkOverdrawColorFilter.h>
 #include <SkPicture.h>
 #include <SkPictureRecorder.h>
 #include "TreeInfo.h"
 #include "VectorDrawable.h"
 #include "utils/TraceUtils.h"

 #include <unistd.h>

 using namespace android::uirenderer::renderthread;

 namespace android {
 namespace uirenderer {
 namespace skiapipeline {

 float SkiaPipeline::mLightRadius = 0;
 uint8_t SkiaPipeline::mAmbientShadowAlpha = 0;
 uint8_t SkiaPipeline::mSpotShadowAlpha = 0;

 Vector3 SkiaPipeline::mLightCenter = {FLT_MIN, FLT_MIN, FLT_MIN};

 SkiaPipeline::SkiaPipeline(RenderThread& thread) : mRenderThread(thread) {
     mVectorDrawables.reserve(30);
 }

 SkiaPipeline::~SkiaPipeline() {
     unpinImages();
 }

 TaskManager* SkiaPipeline::getTaskManager() {
     return mRenderThread.cacheManager().getTaskManager();
 }

 void SkiaPipeline::onDestroyHardwareResources() {
     unpinImages();
     mRenderThread.cacheManager().trimStaleResources();
 }

 bool SkiaPipeline::pinImages(std::vector<SkImage*>& mutableImages) {
     for (SkImage* image : mutableImages) {
         if (SkImage_pinAsTexture(image, mRenderThread.getGrContext())) {
             mPinnedImages.emplace_back(sk_ref_sp(image));
         } else {
             return false;
         }
     }
     return true;
 }

 void SkiaPipeline::unpinImages() {
     for (auto& image : mPinnedImages) {
         SkImage_unpinAsTexture(image.get(), mRenderThread.getGrContext());
     }
     mPinnedImages.clear();
 }

 void SkiaPipeline::onPrepareTree() {
     // The only time mVectorDrawables is not empty is if prepare tree was called 2 times without
     // a renderFrame in the middle.
     mVectorDrawables.clear();
 }

 void SkiaPipeline::renderLayers(const LightGeometry& lightGeometry,
                                 LayerUpdateQueue* layerUpdateQueue, bool opaque,
                                 bool wideColorGamut, const LightInfo& lightInfo) {
     updateLighting(lightGeometry, lightInfo);
     ATRACE_NAME("draw layers");
     renderVectorDrawableCache();
     renderLayersImpl(*layerUpdateQueue, opaque, wideColorGamut);
     layerUpdateQueue->clear();
 }

 void SkiaPipeline::renderLayersImpl(const LayerUpdateQueue& layers, bool opaque,
                                     bool wideColorGamut) {
     sk_sp<GrContext> cachedContext;

     // Render all layers that need to be updated, in order.
     for (size_t i = 0; i < layers.entries().size(); i++) {
         RenderNode* layerNode = layers.entries()[i].renderNode.get();
         // only schedule repaint if node still on layer - possible it may have been
         // removed during a dropped frame, but layers may still remain scheduled so
         // as not to lose info on what portion is damaged
         if (CC_LIKELY(layerNode->getLayerSurface() != nullptr)) {
             SkASSERT(layerNode->getLayerSurface());
             SkiaDisplayList* displayList = (SkiaDisplayList*)layerNode->getDisplayList();
             if (!displayList || displayList->isEmpty()) {
                 SkDEBUGF(("%p drawLayers(%s) : missing drawable", layerNode, layerNode->getName()));
                 return;
             }

             const Rect& layerDamage = layers.entries()[i].damage;

             SkCanvas* layerCanvas = tryCapture(layerNode->getLayerSurface());

             int saveCount = layerCanvas->save();
             SkASSERT(saveCount == 1);

             layerCanvas->androidFramework_setDeviceClipRestriction(layerDamage.toSkIRect());

             auto savedLightCenter = mLightCenter;
             // map current light center into RenderNode's coordinate space
             layerNode->getSkiaLayer()->inverseTransformInWindow.mapPoint3d(mLightCenter);

             const RenderProperties& properties = layerNode->properties();
             const SkRect bounds = SkRect::MakeWH(properties.getWidth(), properties.getHeight());
             if (properties.getClipToBounds() && layerCanvas->quickReject(bounds)) {
                 return;
             }

             ATRACE_FORMAT("drawLayer [%s] %.1f x %.1f", layerNode->getName(), bounds.width(),
                           bounds.height());

             layerNode->getSkiaLayer()->hasRenderedSinceRepaint = false;
             layerCanvas->clear(SK_ColorTRANSPARENT);

             RenderNodeDrawable root(layerNode, layerCanvas, false);
             root.forceDraw(layerCanvas);
             layerCanvas->restoreToCount(saveCount);
             mLightCenter = savedLightCenter;

             endCapture(layerNode->getLayerSurface());

             // cache the current context so that we can defer flushing it until
             // either all the layers have been rendered or the context changes
             GrContext* currentContext = layerNode->getLayerSurface()->getCanvas()->getGrContext();
             if (cachedContext.get() != currentContext) {
                 if (cachedContext.get()) {
                     ATRACE_NAME("flush layers (context changed)");
                     cachedContext->flush();
                 }
                 cachedContext.reset(SkSafeRef(currentContext));
             }
         }
     }

     if (cachedContext.get()) {
         ATRACE_NAME("flush layers");
         cachedContext->flush();
     }
 }

 bool SkiaPipeline::createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
                                        bool wideColorGamut, ErrorHandler* errorHandler) {
     // compute the size of the surface (i.e. texture) to be allocated for this layer
     const int surfaceWidth = ceilf(node->getWidth() / float(LAYER_SIZE)) * LAYER_SIZE;
     const int surfaceHeight = ceilf(node->getHeight() / float(LAYER_SIZE)) * LAYER_SIZE;

     SkSurface* layer = node->getLayerSurface();
     if (!layer || layer->width() != surfaceWidth || layer->height() != surfaceHeight) {
         SkImageInfo info;
         if (wideColorGamut) {
             info = SkImageInfo::Make(surfaceWidth, surfaceHeight, kRGBA_F16_SkColorType,
                                      kPremul_SkAlphaType);
         } else {
             info = SkImageInfo::MakeN32Premul(surfaceWidth, surfaceHeight);
         }
         SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
         SkASSERT(mRenderThread.getGrContext() != nullptr);
         node->setLayerSurface(SkSurface::MakeRenderTarget(mRenderThread.getGrContext(),
                                                           SkBudgeted::kYes, info, 0, &props));
         if (node->getLayerSurface()) {
             // update the transform in window of the layer to reset its origin wrt light source
             // position
             Matrix4 windowTransform;
             damageAccumulator.computeCurrentTransform(&windowTransform);
             node->getSkiaLayer()->inverseTransformInWindow = windowTransform;
         } else {
             String8 cachesOutput;
             mRenderThread.cacheManager().dumpMemoryUsage(cachesOutput,
                     &mRenderThread.renderState());
             ALOGE("%s", cachesOutput.string());
             if (errorHandler) {
                 std::ostringstream err;
                 err << "Unable to create layer for " << node->getName();
                 const int maxTextureSize = DeviceInfo::get()->maxTextureSize();
                 err << ", size " << info.width() << "x" << info.height() << " max size "
                     << maxTextureSize << " color type " << (int)info.colorType()
                     << " has context " << (int)(mRenderThread.getGrContext() != nullptr);
                 errorHandler->onError(err.str());
             }
         }
         return true;
     }
     return false;
 }

 void SkiaPipeline::destroyLayer(RenderNode* node) {
     node->setLayerSurface(nullptr);
 }

 void SkiaPipeline::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
     GrContext* context = thread.getGrContext();
     if (context) {
         ATRACE_FORMAT("Bitmap#prepareToDraw %dx%d", bitmap->width(), bitmap->height());
         sk_sp<SkColorFilter> colorFilter;
         auto image = bitmap->makeImage(&colorFilter);
         if (image.get() && !bitmap->isHardware()) {
             SkImage_pinAsTexture(image.get(), context);
             SkImage_unpinAsTexture(image.get(), context);
         }
     }
 }

 void SkiaPipeline::renderVectorDrawableCache() {
     if (!mVectorDrawables.empty()) {
         sp<VectorDrawableAtlas> atlas = mRenderThread.cacheManager().acquireVectorDrawableAtlas();
         auto grContext = mRenderThread.getGrContext();
         atlas->prepareForDraw(grContext);
         ATRACE_NAME("Update VectorDrawables");
         for (auto vd : mVectorDrawables) {
             vd->updateCache(atlas, grContext);
         }
         mVectorDrawables.clear();
     }
 }

 class SkiaPipeline::SavePictureProcessor : public TaskProcessor<bool> {
 public:
     explicit SavePictureProcessor(TaskManager* taskManager) : TaskProcessor<bool>(taskManager) {}

     struct SavePictureTask : public Task<bool> {
         sk_sp<SkData> data;
         std::string filename;
     };

     void savePicture(const sk_sp<SkData>& data, const std::string& filename) {
         sp<SavePictureTask> task(new SavePictureTask());
         task->data = data;
         task->filename = filename;
         TaskProcessor<bool>::add(task);
     }

     virtual void onProcess(const sp<Task<bool>>& task) override {
         SavePictureTask* t = static_cast<SavePictureTask*>(task.get());

         if (0 == access(t->filename.c_str(), F_OK)) {
             task->setResult(false);
             return;
         }

         SkFILEWStream stream(t->filename.c_str());
         if (stream.isValid()) {
             stream.write(t->data->data(), t->data->size());
             stream.flush();
             SkDebugf("SKP Captured Drawing Output (%d bytes) for frame. %s", stream.bytesWritten(),
                      t->filename.c_str());
         }

         task->setResult(true);
     }
 };

 SkCanvas* SkiaPipeline::tryCapture(SkSurface* surface) {
     if (CC_UNLIKELY(Properties::skpCaptureEnabled)) {
         bool recordingPicture = mCaptureSequence > 0;
         char prop[PROPERTY_VALUE_MAX] = {'\0'};
         if (!recordingPicture) {
             property_get(PROPERTY_CAPTURE_SKP_FILENAME, prop, "0");
             recordingPicture = prop[0] != '0' &&
                                mCapturedFile != prop;  // ensure we capture only once per filename
             if (recordingPicture) {
                 mCapturedFile = prop;
                 mCaptureSequence = property_get_int32(PROPERTY_CAPTURE_SKP_FRAMES, 1);
             }
         }
         if (recordingPicture) {
             mRecorder.reset(new SkPictureRecorder());
             return mRecorder->beginRecording(surface->width(), surface->height(), nullptr,
                                              SkPictureRecorder::kPlaybackDrawPicture_RecordFlag);
         }
     }
     return surface->getCanvas();
 }

 void SkiaPipeline::endCapture(SkSurface* surface) {
     if (CC_UNLIKELY(mRecorder.get())) {
         sk_sp<SkPicture> picture = mRecorder->finishRecordingAsPicture();
         surface->getCanvas()->drawPicture(picture);
         if (picture->approximateOpCount() > 0) {
             auto data = picture->serialize();

             // offload saving to file in a different thread
             if (!mSavePictureProcessor.get()) {
                 TaskManager* taskManager = getTaskManager();
                 mSavePictureProcessor = new SavePictureProcessor(
                         taskManager->canRunTasks() ? taskManager : nullptr);
             }
             if (1 == mCaptureSequence) {
                 mSavePictureProcessor->savePicture(data, mCapturedFile);
             } else {
                 mSavePictureProcessor->savePicture(
                         data,
                         mCapturedFile + "_" + std::to_string(mCaptureSequence));
             }
             mCaptureSequence--;
         }
         mRecorder.reset();
     }
 }

 void SkiaPipeline::renderFrame(const LayerUpdateQueue& layers, const SkRect& clip,
                                const std::vector<sp<RenderNode>>& nodes, bool opaque,
                                bool wideColorGamut, const Rect& contentDrawBounds,
                                sk_sp<SkSurface> surface) {
     renderVectorDrawableCache();

     // draw all layers up front
     renderLayersImpl(layers, opaque, wideColorGamut);

     // initialize the canvas for the current frame, that might be a recording canvas if SKP
     // capture is enabled.
     std::unique_ptr<SkPictureRecorder> recorder;
     SkCanvas* canvas = tryCapture(surface.get());

     renderFrameImpl(layers, clip, nodes, opaque, wideColorGamut, contentDrawBounds, canvas);

     endCapture(surface.get());

     if (CC_UNLIKELY(Properties::debugOverdraw)) {
         renderOverdraw(layers, clip, nodes, contentDrawBounds, surface);
     }

     ATRACE_NAME("flush commands");
     surface->getCanvas()->flush();
 }

 namespace {
 static Rect nodeBounds(RenderNode& node) {
     auto& props = node.properties();
     return Rect(props.getLeft(), props.getTop(), props.getRight(), props.getBottom());
 }
 }

 void SkiaPipeline::renderFrameImpl(const LayerUpdateQueue& layers, const SkRect& clip,
                                    const std::vector<sp<RenderNode>>& nodes, bool opaque,
                                    bool wideColorGamut, const Rect& contentDrawBounds,
                                    SkCanvas* canvas) {
     SkAutoCanvasRestore saver(canvas, true);
     canvas->androidFramework_setDeviceClipRestriction(clip.roundOut());

     // STOPSHIP: Revert, temporary workaround to clear always F16 frame buffer for b/74976293
     if (!opaque || wideColorGamut) {
         canvas->clear(SK_ColorTRANSPARENT);
     }

     if (1 == nodes.size()) {
         if (!nodes[0]->nothingToDraw()) {
             RenderNodeDrawable root(nodes[0].get(), canvas);
             root.draw(canvas);
         }
     } else if (0 == nodes.size()) {
         // nothing to draw
     } else {
         // It there are multiple render nodes, they are laid out as follows:
         // #0 - backdrop (content + caption)
         // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop)
         // #2 - additional overlay nodes
         // Usually the backdrop cannot be seen since it will be entirely covered by the content.
         // While
         // resizing however it might become partially visible. The following render loop will crop
         // the
         // backdrop against the content and draw the remaining part of it. It will then draw the
         // content
         // cropped to the backdrop (since that indicates a shrinking of the window).
         //
         // Additional nodes will be drawn on top with no particular clipping semantics.

         // Usually the contents bounds should be mContentDrawBounds - however - we will
         // move it towards the fixed edge to give it a more stable appearance (for the moment).
         // If there is no content bounds we ignore the layering as stated above and start with 2.

         // Backdrop bounds in render target space
         const Rect backdrop = nodeBounds(*nodes[0]);

         // Bounds that content will fill in render target space (note content node bounds may be
         // bigger)
         Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight());
         content.translate(backdrop.left, backdrop.top);
         if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) {
             // Content doesn't entirely overlap backdrop, so fill around content (right/bottom)

             // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to
             // also fill left/top. Currently, both 2up and freeform position content at the top/left
             // of
             // the backdrop, so this isn't necessary.
             RenderNodeDrawable backdropNode(nodes[0].get(), canvas);
             if (content.right < backdrop.right) {
                 // draw backdrop to right side of content
                 SkAutoCanvasRestore acr(canvas, true);
                 canvas->clipRect(SkRect::MakeLTRB(content.right, backdrop.top, backdrop.right,
                                                   backdrop.bottom));
                 backdropNode.draw(canvas);
             }
             if (content.bottom < backdrop.bottom) {
                 // draw backdrop to bottom of content
                 // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill
                 SkAutoCanvasRestore acr(canvas, true);
                 canvas->clipRect(SkRect::MakeLTRB(content.left, content.bottom, content.right,
                                                   backdrop.bottom));
                 backdropNode.draw(canvas);
             }
         }

         RenderNodeDrawable contentNode(nodes[1].get(), canvas);
         if (!backdrop.isEmpty()) {
             // content node translation to catch up with backdrop
             float dx = backdrop.left - contentDrawBounds.left;
             float dy = backdrop.top - contentDrawBounds.top;

             SkAutoCanvasRestore acr(canvas, true);
             canvas->translate(dx, dy);
             const SkRect contentLocalClip =
                     SkRect::MakeXYWH(contentDrawBounds.left, contentDrawBounds.top,
                                      backdrop.getWidth(), backdrop.getHeight());
             canvas->clipRect(contentLocalClip);
             contentNode.draw(canvas);
         } else {
             SkAutoCanvasRestore acr(canvas, true);
             contentNode.draw(canvas);
         }

         // remaining overlay nodes, simply defer
         for (size_t index = 2; index < nodes.size(); index++) {
             if (!nodes[index]->nothingToDraw()) {
                 SkAutoCanvasRestore acr(canvas, true);
                 RenderNodeDrawable overlayNode(nodes[index].get(), canvas);
                 overlayNode.draw(canvas);
             }
         }
     }
 }

 void SkiaPipeline::dumpResourceCacheUsage() const {
     int resources, maxResources;
     size_t bytes, maxBytes;
     mRenderThread.getGrContext()->getResourceCacheUsage(&resources, &bytes);
     mRenderThread.getGrContext()->getResourceCacheLimits(&maxResources, &maxBytes);

     SkString log("Resource Cache Usage:\n");
     log.appendf("%8d items out of %d maximum items\n", resources, maxResources);
     log.appendf("%8zu bytes (%.2f MB) out of %.2f MB maximum\n", bytes,
                 bytes * (1.0f / (1024.0f * 1024.0f)), maxBytes * (1.0f / (1024.0f * 1024.0f)));

     ALOGD("%s", log.c_str());
 }

 // Overdraw debugging

 // These colors should be kept in sync with Caches::getOverdrawColor() with a few differences.
 // This implementation:
 // (1) Requires transparent entries for "no overdraw" and "single draws".
 // (2) Requires premul colors (instead of unpremul).
 // (3) Requires RGBA colors (instead of BGRA).
 static const uint32_t kOverdrawColors[2][6] = {
         {
                 0x00000000, 0x00000000, 0x2f2f0000, 0x2f002f00, 0x3f00003f, 0x7f00007f,
         },
         {
                 0x00000000, 0x00000000, 0x2f2f0000, 0x4f004f4f, 0x5f50335f, 0x7f00007f,
         },
 };

 void SkiaPipeline::renderOverdraw(const LayerUpdateQueue& layers, const SkRect& clip,
                                   const std::vector<sp<RenderNode>>& nodes,
                                   const Rect& contentDrawBounds, sk_sp<SkSurface> surface) {
     // Set up the overdraw canvas.
     SkImageInfo offscreenInfo = SkImageInfo::MakeA8(surface->width(), surface->height());
     sk_sp<SkSurface> offscreen = surface->makeSurface(offscreenInfo);
     SkOverdrawCanvas overdrawCanvas(offscreen->getCanvas());

     // Fake a redraw to replay the draw commands.  This will increment the alpha channel
     // each time a pixel would have been drawn.
     // Pass true for opaque so we skip the clear - the overdrawCanvas is already zero
     // initialized.
     renderFrameImpl(layers, clip, nodes, true, false, contentDrawBounds, &overdrawCanvas);
     sk_sp<SkImage> counts = offscreen->makeImageSnapshot();

     // Draw overdraw colors to the canvas.  The color filter will convert counts to colors.
     SkPaint paint;
     const SkPMColor* colors = kOverdrawColors[static_cast<int>(Properties::overdrawColorSet)];
     paint.setColorFilter(SkOverdrawColorFilter::Make(colors));
     surface->getCanvas()->drawImage(counts.get(), 0.0f, 0.0f, &paint);
 }

 } /* namespace skiapipeline */
 } /* namespace uirenderer */
 } /* namespace android */
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "SkiaPipeline.h"

	#include <SkImageEncoder.h>
	#include <SkImagePriv.h>
	#include <SkOverdrawCanvas.h>
	#include <SkOverdrawColorFilter.h>
	#include <SkPicture.h>
	#include <SkPictureRecorder.h>
	#include "TreeInfo.h"
	#include "VectorDrawable.h"
	#include "utils/TraceUtils.h"

	#include <unistd.h>

	using namespace android::uirenderer::renderthread;

	namespace android {
	namespace uirenderer {
	namespace skiapipeline {

	float SkiaPipeline::mLightRadius = 0;
	uint8_t SkiaPipeline::mAmbientShadowAlpha = 0;
	uint8_t SkiaPipeline::mSpotShadowAlpha = 0;

	Vector3 SkiaPipeline::mLightCenter = {FLT_MIN, FLT_MIN, FLT_MIN};

	SkiaPipeline::SkiaPipeline(RenderThread& thread) : mRenderThread(thread) {
	mVectorDrawables.reserve(30);
	}

	SkiaPipeline::~SkiaPipeline() {
	unpinImages();
	}

	TaskManager* SkiaPipeline::getTaskManager() {
	return mRenderThread.cacheManager().getTaskManager();
	}

	void SkiaPipeline::onDestroyHardwareResources() {
	unpinImages();
	mRenderThread.cacheManager().trimStaleResources();
	}

	bool SkiaPipeline::pinImages(std::vector<SkImage*>& mutableImages) {
	for (SkImage* image : mutableImages) {
	if (SkImage_pinAsTexture(image, mRenderThread.getGrContext())) {
	mPinnedImages.emplace_back(sk_ref_sp(image));
	} else {
	return false;
	}
	}
	return true;
	}

	void SkiaPipeline::unpinImages() {
	for (auto& image : mPinnedImages) {
	SkImage_unpinAsTexture(image.get(), mRenderThread.getGrContext());
	}
	mPinnedImages.clear();
	}

	void SkiaPipeline::onPrepareTree() {
	// The only time mVectorDrawables is not empty is if prepare tree was called 2 times without
	// a renderFrame in the middle.
	mVectorDrawables.clear();
	}

	void SkiaPipeline::renderLayers(const LightGeometry& lightGeometry,
	LayerUpdateQueue* layerUpdateQueue, bool opaque,
	bool wideColorGamut, const LightInfo& lightInfo) {
	updateLighting(lightGeometry, lightInfo);
	ATRACE_NAME("draw layers");
	renderVectorDrawableCache();
	renderLayersImpl(*layerUpdateQueue, opaque, wideColorGamut);
	layerUpdateQueue->clear();
	}

	void SkiaPipeline::renderLayersImpl(const LayerUpdateQueue& layers, bool opaque,
	bool wideColorGamut) {
	sk_sp<GrContext> cachedContext;

	// Render all layers that need to be updated, in order.
	for (size_t i = 0; i < layers.entries().size(); i++) {
	RenderNode* layerNode = layers.entries()[i].renderNode.get();
	// only schedule repaint if node still on layer - possible it may have been
	// removed during a dropped frame, but layers may still remain scheduled so
	// as not to lose info on what portion is damaged
	if (CC_LIKELY(layerNode->getLayerSurface() != nullptr)) {
	SkASSERT(layerNode->getLayerSurface());
	SkiaDisplayList* displayList = (SkiaDisplayList*)layerNode->getDisplayList();
	if (!displayList \|\| displayList->isEmpty()) {
	SkDEBUGF(("%p drawLayers(%s) : missing drawable", layerNode, layerNode->getName()));
	return;
	}

	const Rect& layerDamage = layers.entries()[i].damage;

	SkCanvas* layerCanvas = tryCapture(layerNode->getLayerSurface());

	int saveCount = layerCanvas->save();
	SkASSERT(saveCount == 1);

	layerCanvas->androidFramework_setDeviceClipRestriction(layerDamage.toSkIRect());

	auto savedLightCenter = mLightCenter;
	// map current light center into RenderNode's coordinate space
	layerNode->getSkiaLayer()->inverseTransformInWindow.mapPoint3d(mLightCenter);

	const RenderProperties& properties = layerNode->properties();
	const SkRect bounds = SkRect::MakeWH(properties.getWidth(), properties.getHeight());
	if (properties.getClipToBounds() && layerCanvas->quickReject(bounds)) {
	return;
	}

	ATRACE_FORMAT("drawLayer [%s] %.1f x %.1f", layerNode->getName(), bounds.width(),
	bounds.height());

	layerNode->getSkiaLayer()->hasRenderedSinceRepaint = false;
	layerCanvas->clear(SK_ColorTRANSPARENT);

	RenderNodeDrawable root(layerNode, layerCanvas, false);
	root.forceDraw(layerCanvas);
	layerCanvas->restoreToCount(saveCount);
	mLightCenter = savedLightCenter;

	endCapture(layerNode->getLayerSurface());

	// cache the current context so that we can defer flushing it until
	// either all the layers have been rendered or the context changes
	GrContext* currentContext = layerNode->getLayerSurface()->getCanvas()->getGrContext();
	if (cachedContext.get() != currentContext) {
	if (cachedContext.get()) {
	ATRACE_NAME("flush layers (context changed)");
	cachedContext->flush();
	}
	cachedContext.reset(SkSafeRef(currentContext));
	}
	}
	}

	if (cachedContext.get()) {
	ATRACE_NAME("flush layers");
	cachedContext->flush();
	}
	}

	bool SkiaPipeline::createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
	bool wideColorGamut, ErrorHandler* errorHandler) {
	// compute the size of the surface (i.e. texture) to be allocated for this layer
	const int surfaceWidth = ceilf(node->getWidth() / float(LAYER_SIZE)) * LAYER_SIZE;
	const int surfaceHeight = ceilf(node->getHeight() / float(LAYER_SIZE)) * LAYER_SIZE;

	SkSurface* layer = node->getLayerSurface();
	if (!layer \|\| layer->width() != surfaceWidth \|\| layer->height() != surfaceHeight) {
	SkImageInfo info;
	if (wideColorGamut) {
	info = SkImageInfo::Make(surfaceWidth, surfaceHeight, kRGBA_F16_SkColorType,
	kPremul_SkAlphaType);
	} else {
	info = SkImageInfo::MakeN32Premul(surfaceWidth, surfaceHeight);
	}
	SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
	SkASSERT(mRenderThread.getGrContext() != nullptr);
	node->setLayerSurface(SkSurface::MakeRenderTarget(mRenderThread.getGrContext(),
	SkBudgeted::kYes, info, 0, &props));
	if (node->getLayerSurface()) {
	// update the transform in window of the layer to reset its origin wrt light source
	// position
	Matrix4 windowTransform;
	damageAccumulator.computeCurrentTransform(&windowTransform);
	node->getSkiaLayer()->inverseTransformInWindow = windowTransform;
	} else {
	String8 cachesOutput;
	mRenderThread.cacheManager().dumpMemoryUsage(cachesOutput,
	&mRenderThread.renderState());
	ALOGE("%s", cachesOutput.string());
	if (errorHandler) {
	std::ostringstream err;
	err << "Unable to create layer for " << node->getName();
	const int maxTextureSize = DeviceInfo::get()->maxTextureSize();
	err << ", size " << info.width() << "x" << info.height() << " max size "
	<< maxTextureSize << " color type " << (int)info.colorType()
	<< " has context " << (int)(mRenderThread.getGrContext() != nullptr);
	errorHandler->onError(err.str());
	}
	}
	return true;
	}
	return false;
	}

	void SkiaPipeline::destroyLayer(RenderNode* node) {
	node->setLayerSurface(nullptr);
	}

	void SkiaPipeline::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
	GrContext* context = thread.getGrContext();
	if (context) {
	ATRACE_FORMAT("Bitmap#prepareToDraw %dx%d", bitmap->width(), bitmap->height());
	sk_sp<SkColorFilter> colorFilter;
	auto image = bitmap->makeImage(&colorFilter);
	if (image.get() && !bitmap->isHardware()) {
	SkImage_pinAsTexture(image.get(), context);
	SkImage_unpinAsTexture(image.get(), context);
	}
	}
	}

	void SkiaPipeline::renderVectorDrawableCache() {
	if (!mVectorDrawables.empty()) {
	sp<VectorDrawableAtlas> atlas = mRenderThread.cacheManager().acquireVectorDrawableAtlas();
	auto grContext = mRenderThread.getGrContext();
	atlas->prepareForDraw(grContext);
	ATRACE_NAME("Update VectorDrawables");
	for (auto vd : mVectorDrawables) {
	vd->updateCache(atlas, grContext);
	}
	mVectorDrawables.clear();
	}
	}

	class SkiaPipeline::SavePictureProcessor : public TaskProcessor<bool> {
	public:
	explicit SavePictureProcessor(TaskManager* taskManager) : TaskProcessor<bool>(taskManager) {}

	struct SavePictureTask : public Task<bool> {
	sk_sp<SkData> data;
	std::string filename;
	};

	void savePicture(const sk_sp<SkData>& data, const std::string& filename) {
	sp<SavePictureTask> task(new SavePictureTask());
	task->data = data;
	task->filename = filename;
	TaskProcessor<bool>::add(task);
	}

	virtual void onProcess(const sp<Task<bool>>& task) override {
	SavePictureTask* t = static_cast<SavePictureTask*>(task.get());

	if (0 == access(t->filename.c_str(), F_OK)) {
	task->setResult(false);
	return;
	}

	SkFILEWStream stream(t->filename.c_str());
	if (stream.isValid()) {
	stream.write(t->data->data(), t->data->size());
	stream.flush();
	SkDebugf("SKP Captured Drawing Output (%d bytes) for frame. %s", stream.bytesWritten(),
	t->filename.c_str());
	}

	task->setResult(true);
	}
	};

	SkCanvas* SkiaPipeline::tryCapture(SkSurface* surface) {
	if (CC_UNLIKELY(Properties::skpCaptureEnabled)) {
	bool recordingPicture = mCaptureSequence > 0;
	char prop[PROPERTY_VALUE_MAX] = {'\0'};
	if (!recordingPicture) {
	property_get(PROPERTY_CAPTURE_SKP_FILENAME, prop, "0");
	recordingPicture = prop[0] != '0' &&
	mCapturedFile != prop; // ensure we capture only once per filename
	if (recordingPicture) {
	mCapturedFile = prop;
	mCaptureSequence = property_get_int32(PROPERTY_CAPTURE_SKP_FRAMES, 1);
	}
	}
	if (recordingPicture) {
	mRecorder.reset(new SkPictureRecorder());
	return mRecorder->beginRecording(surface->width(), surface->height(), nullptr,
	SkPictureRecorder::kPlaybackDrawPicture_RecordFlag);
	}
	}
	return surface->getCanvas();
	}

	void SkiaPipeline::endCapture(SkSurface* surface) {
	if (CC_UNLIKELY(mRecorder.get())) {
	sk_sp<SkPicture> picture = mRecorder->finishRecordingAsPicture();
	surface->getCanvas()->drawPicture(picture);
	if (picture->approximateOpCount() > 0) {
	auto data = picture->serialize();

	// offload saving to file in a different thread
	if (!mSavePictureProcessor.get()) {
	TaskManager* taskManager = getTaskManager();
	mSavePictureProcessor = new SavePictureProcessor(
	taskManager->canRunTasks() ? taskManager : nullptr);
	}
	if (1 == mCaptureSequence) {
	mSavePictureProcessor->savePicture(data, mCapturedFile);
	} else {
	mSavePictureProcessor->savePicture(
	data,
	mCapturedFile + "_" + std::to_string(mCaptureSequence));
	}
	mCaptureSequence--;
	}
	mRecorder.reset();
	}
	}

	void SkiaPipeline::renderFrame(const LayerUpdateQueue& layers, const SkRect& clip,
	const std::vector<sp<RenderNode>>& nodes, bool opaque,
	bool wideColorGamut, const Rect& contentDrawBounds,
	sk_sp<SkSurface> surface) {
	renderVectorDrawableCache();

	// draw all layers up front
	renderLayersImpl(layers, opaque, wideColorGamut);

	// initialize the canvas for the current frame, that might be a recording canvas if SKP
	// capture is enabled.
	std::unique_ptr<SkPictureRecorder> recorder;
	SkCanvas* canvas = tryCapture(surface.get());

	renderFrameImpl(layers, clip, nodes, opaque, wideColorGamut, contentDrawBounds, canvas);

	endCapture(surface.get());

	if (CC_UNLIKELY(Properties::debugOverdraw)) {
	renderOverdraw(layers, clip, nodes, contentDrawBounds, surface);
	}

	ATRACE_NAME("flush commands");
	surface->getCanvas()->flush();
	}

	namespace {
	static Rect nodeBounds(RenderNode& node) {
	auto& props = node.properties();
	return Rect(props.getLeft(), props.getTop(), props.getRight(), props.getBottom());
	}
	}

	void SkiaPipeline::renderFrameImpl(const LayerUpdateQueue& layers, const SkRect& clip,
	const std::vector<sp<RenderNode>>& nodes, bool opaque,
	bool wideColorGamut, const Rect& contentDrawBounds,
	SkCanvas* canvas) {
	SkAutoCanvasRestore saver(canvas, true);
	canvas->androidFramework_setDeviceClipRestriction(clip.roundOut());

	// STOPSHIP: Revert, temporary workaround to clear always F16 frame buffer for b/74976293
	if (!opaque \|\| wideColorGamut) {
	canvas->clear(SK_ColorTRANSPARENT);
	}

	if (1 == nodes.size()) {
	if (!nodes[0]->nothingToDraw()) {
	RenderNodeDrawable root(nodes[0].get(), canvas);
	root.draw(canvas);
	}
	} else if (0 == nodes.size()) {
	// nothing to draw
	} else {
	// It there are multiple render nodes, they are laid out as follows:
	// #0 - backdrop (content + caption)
	// #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop)
	// #2 - additional overlay nodes
	// Usually the backdrop cannot be seen since it will be entirely covered by the content.
	// While
	// resizing however it might become partially visible. The following render loop will crop
	// the
	// backdrop against the content and draw the remaining part of it. It will then draw the
	// content
	// cropped to the backdrop (since that indicates a shrinking of the window).
	//
	// Additional nodes will be drawn on top with no particular clipping semantics.

	// Usually the contents bounds should be mContentDrawBounds - however - we will
	// move it towards the fixed edge to give it a more stable appearance (for the moment).
	// If there is no content bounds we ignore the layering as stated above and start with 2.

	// Backdrop bounds in render target space
	const Rect backdrop = nodeBounds(*nodes[0]);

	// Bounds that content will fill in render target space (note content node bounds may be
	// bigger)
	Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight());
	content.translate(backdrop.left, backdrop.top);
	if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) {
	// Content doesn't entirely overlap backdrop, so fill around content (right/bottom)

	// Note: in the future, if content doesn't snap to backdrop's left/top, this may need to
	// also fill left/top. Currently, both 2up and freeform position content at the top/left
	// of
	// the backdrop, so this isn't necessary.
	RenderNodeDrawable backdropNode(nodes[0].get(), canvas);
	if (content.right < backdrop.right) {
	// draw backdrop to right side of content
	SkAutoCanvasRestore acr(canvas, true);
	canvas->clipRect(SkRect::MakeLTRB(content.right, backdrop.top, backdrop.right,
	backdrop.bottom));
	backdropNode.draw(canvas);
	}
	if (content.bottom < backdrop.bottom) {
	// draw backdrop to bottom of content
	// Note: bottom fill uses content left/right, to avoid overdrawing left/right fill
	SkAutoCanvasRestore acr(canvas, true);
	canvas->clipRect(SkRect::MakeLTRB(content.left, content.bottom, content.right,
	backdrop.bottom));
	backdropNode.draw(canvas);
	}
	}

	RenderNodeDrawable contentNode(nodes[1].get(), canvas);
	if (!backdrop.isEmpty()) {
	// content node translation to catch up with backdrop
	float dx = backdrop.left - contentDrawBounds.left;
	float dy = backdrop.top - contentDrawBounds.top;

	SkAutoCanvasRestore acr(canvas, true);
	canvas->translate(dx, dy);
	const SkRect contentLocalClip =
	SkRect::MakeXYWH(contentDrawBounds.left, contentDrawBounds.top,
	backdrop.getWidth(), backdrop.getHeight());
	canvas->clipRect(contentLocalClip);
	contentNode.draw(canvas);
	} else {
	SkAutoCanvasRestore acr(canvas, true);
	contentNode.draw(canvas);
	}

	// remaining overlay nodes, simply defer
	for (size_t index = 2; index < nodes.size(); index++) {
	if (!nodes[index]->nothingToDraw()) {
	SkAutoCanvasRestore acr(canvas, true);
	RenderNodeDrawable overlayNode(nodes[index].get(), canvas);
	overlayNode.draw(canvas);
	}
	}
	}
	}

	void SkiaPipeline::dumpResourceCacheUsage() const {
	int resources, maxResources;
	size_t bytes, maxBytes;
	mRenderThread.getGrContext()->getResourceCacheUsage(&resources, &bytes);
	mRenderThread.getGrContext()->getResourceCacheLimits(&maxResources, &maxBytes);

	SkString log("Resource Cache Usage:\n");
	log.appendf("%8d items out of %d maximum items\n", resources, maxResources);
	log.appendf("%8zu bytes (%.2f MB) out of %.2f MB maximum\n", bytes,
	bytes * (1.0f / (1024.0f * 1024.0f)), maxBytes * (1.0f / (1024.0f * 1024.0f)));

	ALOGD("%s", log.c_str());
	}

	// Overdraw debugging

	// These colors should be kept in sync with Caches::getOverdrawColor() with a few differences.
	// This implementation:
	// (1) Requires transparent entries for "no overdraw" and "single draws".
	// (2) Requires premul colors (instead of unpremul).
	// (3) Requires RGBA colors (instead of BGRA).
	static const uint32_t kOverdrawColors[2][6] = {
	{
	0x00000000, 0x00000000, 0x2f2f0000, 0x2f002f00, 0x3f00003f, 0x7f00007f,
	},
	{
	0x00000000, 0x00000000, 0x2f2f0000, 0x4f004f4f, 0x5f50335f, 0x7f00007f,
	},
	};

	void SkiaPipeline::renderOverdraw(const LayerUpdateQueue& layers, const SkRect& clip,
	const std::vector<sp<RenderNode>>& nodes,
	const Rect& contentDrawBounds, sk_sp<SkSurface> surface) {
	// Set up the overdraw canvas.
	SkImageInfo offscreenInfo = SkImageInfo::MakeA8(surface->width(), surface->height());
	sk_sp<SkSurface> offscreen = surface->makeSurface(offscreenInfo);
	SkOverdrawCanvas overdrawCanvas(offscreen->getCanvas());

	// Fake a redraw to replay the draw commands. This will increment the alpha channel
	// each time a pixel would have been drawn.
	// Pass true for opaque so we skip the clear - the overdrawCanvas is already zero
	// initialized.
	renderFrameImpl(layers, clip, nodes, true, false, contentDrawBounds, &overdrawCanvas);
	sk_sp<SkImage> counts = offscreen->makeImageSnapshot();

	// Draw overdraw colors to the canvas. The color filter will convert counts to colors.
	SkPaint paint;
	const SkPMColor* colors = kOverdrawColors[static_cast<int>(Properties::overdrawColorSet)];
	paint.setColorFilter(SkOverdrawColorFilter::Make(colors));
	surface->getCanvas()->drawImage(counts.get(), 0.0f, 0.0f, &paint);
	}

	} /* namespace skiapipeline */
	} /* namespace uirenderer */
	} /* namespace android */