Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "SkiaPipeline.h" |
| 18 | |
Hal Canary | 10219fb | 2016-11-23 20:41:22 -0500 | [diff] [blame] | 19 | #include <SkImageEncoder.h> |
Leon Scroggins III | ee708fa | 2016-12-12 15:31:39 -0500 | [diff] [blame] | 20 | #include <SkImagePriv.h> |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 21 | #include <SkOverdrawCanvas.h> |
| 22 | #include <SkOverdrawColorFilter.h> |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 23 | #include <SkPicture.h> |
| 24 | #include <SkPictureRecorder.h> |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 25 | #include "VectorDrawable.h" |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 26 | #include "utils/TraceUtils.h" |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 27 | |
Ben Wagner | 3aeda5c | 2017-03-17 17:22:01 -0400 | [diff] [blame] | 28 | #include <unistd.h> |
| 29 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 30 | using namespace android::uirenderer::renderthread; |
| 31 | |
| 32 | namespace android { |
| 33 | namespace uirenderer { |
| 34 | namespace skiapipeline { |
| 35 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 36 | float SkiaPipeline::mLightRadius = 0; |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 37 | uint8_t SkiaPipeline::mAmbientShadowAlpha = 0; |
| 38 | uint8_t SkiaPipeline::mSpotShadowAlpha = 0; |
| 39 | |
| 40 | Vector3 SkiaPipeline::mLightCenter = {FLT_MIN, FLT_MIN, FLT_MIN}; |
| 41 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 42 | SkiaPipeline::SkiaPipeline(RenderThread& thread) : mRenderThread(thread) { |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 43 | mVectorDrawables.reserve(30); |
| 44 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 45 | |
Stan Iliev | 232f362 | 2017-08-23 17:15:09 -0400 | [diff] [blame] | 46 | SkiaPipeline::~SkiaPipeline() { |
| 47 | unpinImages(); |
| 48 | } |
| 49 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 50 | TaskManager* SkiaPipeline::getTaskManager() { |
Derek Sollenberger | 8ec9e88 | 2017-08-24 16:36:08 -0400 | [diff] [blame] | 51 | return mRenderThread.cacheManager().getTaskManager(); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | void SkiaPipeline::onDestroyHardwareResources() { |
Derek Sollenberger | f9e45d1 | 2017-06-01 13:07:39 -0400 | [diff] [blame] | 55 | mRenderThread.cacheManager().trimStaleResources(); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 56 | } |
| 57 | |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 58 | bool SkiaPipeline::pinImages(std::vector<SkImage*>& mutableImages) { |
| 59 | for (SkImage* image : mutableImages) { |
Derek Sollenberger | 189e874 | 2016-11-16 16:00:17 -0500 | [diff] [blame] | 60 | if (SkImage_pinAsTexture(image, mRenderThread.getGrContext())) { |
| 61 | mPinnedImages.emplace_back(sk_ref_sp(image)); |
| 62 | } else { |
| 63 | return false; |
| 64 | } |
Derek Sollenberger | b7d34b6 | 2016-11-04 10:46:18 -0400 | [diff] [blame] | 65 | } |
| 66 | return true; |
| 67 | } |
| 68 | |
| 69 | void SkiaPipeline::unpinImages() { |
| 70 | for (auto& image : mPinnedImages) { |
| 71 | SkImage_unpinAsTexture(image.get(), mRenderThread.getGrContext()); |
| 72 | } |
| 73 | mPinnedImages.clear(); |
| 74 | } |
| 75 | |
Stan Iliev | 47fed6ba | 2017-10-18 17:56:43 -0400 | [diff] [blame] | 76 | void SkiaPipeline::onPrepareTree() { |
| 77 | // The only time mVectorDrawables is not empty is if prepare tree was called 2 times without |
| 78 | // a renderFrame in the middle. |
| 79 | mVectorDrawables.clear(); |
| 80 | } |
| 81 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 82 | void SkiaPipeline::renderLayers(const FrameBuilder::LightGeometry& lightGeometry, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 83 | LayerUpdateQueue* layerUpdateQueue, bool opaque, |
| 84 | bool wideColorGamut, const BakedOpRenderer::LightInfo& lightInfo) { |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 85 | updateLighting(lightGeometry, lightInfo); |
| 86 | ATRACE_NAME("draw layers"); |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 87 | renderVectorDrawableCache(); |
Romain Guy | 07ae505 | 2017-06-13 18:25:32 -0700 | [diff] [blame] | 88 | renderLayersImpl(*layerUpdateQueue, opaque, wideColorGamut); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 89 | layerUpdateQueue->clear(); |
| 90 | } |
| 91 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 92 | void SkiaPipeline::renderLayersImpl(const LayerUpdateQueue& layers, bool opaque, |
| 93 | bool wideColorGamut) { |
Derek Sollenberger | f7df184 | 2017-09-05 11:15:58 -0400 | [diff] [blame] | 94 | sk_sp<GrContext> cachedContext; |
| 95 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 96 | // Render all layers that need to be updated, in order. |
| 97 | for (size_t i = 0; i < layers.entries().size(); i++) { |
John Reck | fc29f7acd | 2017-03-02 13:23:16 -0800 | [diff] [blame] | 98 | RenderNode* layerNode = layers.entries()[i].renderNode.get(); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 99 | // only schedule repaint if node still on layer - possible it may have been |
| 100 | // removed during a dropped frame, but layers may still remain scheduled so |
| 101 | // as not to lose info on what portion is damaged |
| 102 | if (CC_LIKELY(layerNode->getLayerSurface() != nullptr)) { |
| 103 | SkASSERT(layerNode->getLayerSurface()); |
| 104 | SkASSERT(layerNode->getDisplayList()->isSkiaDL()); |
| 105 | SkiaDisplayList* displayList = (SkiaDisplayList*)layerNode->getDisplayList(); |
| 106 | if (!displayList || displayList->isEmpty()) { |
Stan Iliev | 18b388d | 2017-07-18 16:41:48 -0400 | [diff] [blame] | 107 | SkDEBUGF(("%p drawLayers(%s) : missing drawable", layerNode, layerNode->getName())); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 108 | return; |
| 109 | } |
| 110 | |
| 111 | const Rect& layerDamage = layers.entries()[i].damage; |
| 112 | |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 113 | SkCanvas* layerCanvas = tryCapture(layerNode->getLayerSurface()); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 114 | |
| 115 | int saveCount = layerCanvas->save(); |
| 116 | SkASSERT(saveCount == 1); |
| 117 | |
Stan Iliev | b66b8bb | 2016-12-15 18:17:42 -0500 | [diff] [blame] | 118 | layerCanvas->androidFramework_setDeviceClipRestriction(layerDamage.toSkIRect()); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 119 | |
| 120 | auto savedLightCenter = mLightCenter; |
| 121 | // map current light center into RenderNode's coordinate space |
| 122 | layerNode->getSkiaLayer()->inverseTransformInWindow.mapPoint3d(mLightCenter); |
| 123 | |
| 124 | const RenderProperties& properties = layerNode->properties(); |
| 125 | const SkRect bounds = SkRect::MakeWH(properties.getWidth(), properties.getHeight()); |
| 126 | if (properties.getClipToBounds() && layerCanvas->quickReject(bounds)) { |
| 127 | return; |
| 128 | } |
| 129 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 130 | ATRACE_FORMAT("drawLayer [%s] %.1f x %.1f", layerNode->getName(), bounds.width(), |
| 131 | bounds.height()); |
Derek Sollenberger | 9552c2c | 2017-08-31 15:37:52 -0400 | [diff] [blame] | 132 | |
Matt Sarett | 79756be | 2016-11-09 16:13:54 -0500 | [diff] [blame] | 133 | layerNode->getSkiaLayer()->hasRenderedSinceRepaint = false; |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 134 | layerCanvas->clear(SK_ColorTRANSPARENT); |
| 135 | |
| 136 | RenderNodeDrawable root(layerNode, layerCanvas, false); |
| 137 | root.forceDraw(layerCanvas); |
| 138 | layerCanvas->restoreToCount(saveCount); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 139 | mLightCenter = savedLightCenter; |
Derek Sollenberger | f7df184 | 2017-09-05 11:15:58 -0400 | [diff] [blame] | 140 | |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 141 | endCapture(layerNode->getLayerSurface()); |
| 142 | |
Derek Sollenberger | f7df184 | 2017-09-05 11:15:58 -0400 | [diff] [blame] | 143 | // cache the current context so that we can defer flushing it until |
| 144 | // either all the layers have been rendered or the context changes |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 145 | GrContext* currentContext = layerNode->getLayerSurface()->getCanvas()->getGrContext(); |
Derek Sollenberger | f7df184 | 2017-09-05 11:15:58 -0400 | [diff] [blame] | 146 | if (cachedContext.get() != currentContext) { |
| 147 | if (cachedContext.get()) { |
| 148 | cachedContext->flush(); |
| 149 | } |
| 150 | cachedContext.reset(SkSafeRef(currentContext)); |
| 151 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 152 | } |
| 153 | } |
Derek Sollenberger | f7df184 | 2017-09-05 11:15:58 -0400 | [diff] [blame] | 154 | |
| 155 | if (cachedContext.get()) { |
| 156 | cachedContext->flush(); |
| 157 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 158 | } |
| 159 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 160 | bool SkiaPipeline::createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator, |
| 161 | bool wideColorGamut) { |
Derek Sollenberger | 03e6cff7 | 2017-12-04 15:07:08 -0500 | [diff] [blame] | 162 | // compute the size of the surface (i.e. texture) to be allocated for this layer |
| 163 | const int surfaceWidth = ceilf(node->getWidth() / float(LAYER_SIZE)) * LAYER_SIZE; |
| 164 | const int surfaceHeight = ceilf(node->getHeight() / float(LAYER_SIZE)) * LAYER_SIZE; |
| 165 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 166 | SkSurface* layer = node->getLayerSurface(); |
Derek Sollenberger | 03e6cff7 | 2017-12-04 15:07:08 -0500 | [diff] [blame] | 167 | if (!layer || layer->width() != surfaceWidth || layer->height() != surfaceHeight) { |
Stan Iliev | 08fc19a | 2017-07-24 10:20:33 -0400 | [diff] [blame] | 168 | SkImageInfo info; |
| 169 | if (wideColorGamut) { |
Derek Sollenberger | 03e6cff7 | 2017-12-04 15:07:08 -0500 | [diff] [blame] | 170 | info = SkImageInfo::Make(surfaceWidth, surfaceHeight, kRGBA_F16_SkColorType, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 171 | kPremul_SkAlphaType); |
Stan Iliev | 08fc19a | 2017-07-24 10:20:33 -0400 | [diff] [blame] | 172 | } else { |
Derek Sollenberger | 03e6cff7 | 2017-12-04 15:07:08 -0500 | [diff] [blame] | 173 | info = SkImageInfo::MakeN32Premul(surfaceWidth, surfaceHeight); |
Stan Iliev | 08fc19a | 2017-07-24 10:20:33 -0400 | [diff] [blame] | 174 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 175 | SkSurfaceProps props(0, kUnknown_SkPixelGeometry); |
| 176 | SkASSERT(mRenderThread.getGrContext() != nullptr); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 177 | node->setLayerSurface(SkSurface::MakeRenderTarget(mRenderThread.getGrContext(), |
| 178 | SkBudgeted::kYes, info, 0, &props)); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 179 | if (node->getLayerSurface()) { |
| 180 | // update the transform in window of the layer to reset its origin wrt light source |
| 181 | // position |
| 182 | Matrix4 windowTransform; |
| 183 | damageAccumulator.computeCurrentTransform(&windowTransform); |
| 184 | node->getSkiaLayer()->inverseTransformInWindow = windowTransform; |
| 185 | } |
| 186 | return true; |
| 187 | } |
| 188 | return false; |
| 189 | } |
| 190 | |
| 191 | void SkiaPipeline::destroyLayer(RenderNode* node) { |
| 192 | node->setLayerSurface(nullptr); |
| 193 | } |
| 194 | |
| 195 | void SkiaPipeline::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) { |
| 196 | GrContext* context = thread.getGrContext(); |
| 197 | if (context) { |
| 198 | ATRACE_FORMAT("Bitmap#prepareToDraw %dx%d", bitmap->width(), bitmap->height()); |
Derek Sollenberger | fb0c8fc | 2017-07-26 13:53:27 -0400 | [diff] [blame] | 199 | sk_sp<SkColorFilter> colorFilter; |
| 200 | auto image = bitmap->makeImage(&colorFilter); |
Stan Iliev | 7bc3bc6 | 2017-05-24 13:28:36 -0400 | [diff] [blame] | 201 | if (image.get() && !bitmap->isHardware()) { |
| 202 | SkImage_pinAsTexture(image.get(), context); |
| 203 | SkImage_unpinAsTexture(image.get(), context); |
| 204 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 205 | } |
| 206 | } |
| 207 | |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 208 | void SkiaPipeline::renderVectorDrawableCache() { |
Stan Iliev | 3310fb1 | 2017-03-23 16:56:51 -0400 | [diff] [blame] | 209 | if (!mVectorDrawables.empty()) { |
| 210 | sp<VectorDrawableAtlas> atlas = mRenderThread.cacheManager().acquireVectorDrawableAtlas(); |
| 211 | auto grContext = mRenderThread.getGrContext(); |
| 212 | atlas->prepareForDraw(grContext); |
Derek Sollenberger | 9552c2c | 2017-08-31 15:37:52 -0400 | [diff] [blame] | 213 | ATRACE_NAME("Update VectorDrawables"); |
Stan Iliev | 3310fb1 | 2017-03-23 16:56:51 -0400 | [diff] [blame] | 214 | for (auto vd : mVectorDrawables) { |
| 215 | vd->updateCache(atlas, grContext); |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 216 | } |
Stan Iliev | 3310fb1 | 2017-03-23 16:56:51 -0400 | [diff] [blame] | 217 | mVectorDrawables.clear(); |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 218 | } |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 219 | } |
| 220 | |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 221 | class SkiaPipeline::SavePictureProcessor : public TaskProcessor<bool> { |
| 222 | public: |
| 223 | explicit SavePictureProcessor(TaskManager* taskManager) : TaskProcessor<bool>(taskManager) {} |
| 224 | |
| 225 | struct SavePictureTask : public Task<bool> { |
| 226 | sk_sp<SkData> data; |
| 227 | std::string filename; |
| 228 | }; |
| 229 | |
| 230 | void savePicture(const sk_sp<SkData>& data, const std::string& filename) { |
| 231 | sp<SavePictureTask> task(new SavePictureTask()); |
| 232 | task->data = data; |
| 233 | task->filename = filename; |
| 234 | TaskProcessor<bool>::add(task); |
| 235 | } |
| 236 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 237 | virtual void onProcess(const sp<Task<bool>>& task) override { |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 238 | SavePictureTask* t = static_cast<SavePictureTask*>(task.get()); |
| 239 | |
| 240 | if (0 == access(t->filename.c_str(), F_OK)) { |
| 241 | task->setResult(false); |
| 242 | return; |
| 243 | } |
| 244 | |
| 245 | SkFILEWStream stream(t->filename.c_str()); |
| 246 | if (stream.isValid()) { |
| 247 | stream.write(t->data->data(), t->data->size()); |
| 248 | stream.flush(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 249 | SkDebugf("SKP Captured Drawing Output (%d bytes) for frame. %s", stream.bytesWritten(), |
| 250 | t->filename.c_str()); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | task->setResult(true); |
| 254 | } |
| 255 | }; |
| 256 | |
| 257 | SkCanvas* SkiaPipeline::tryCapture(SkSurface* surface) { |
| 258 | if (CC_UNLIKELY(Properties::skpCaptureEnabled)) { |
| 259 | bool recordingPicture = mCaptureSequence > 0; |
| 260 | char prop[PROPERTY_VALUE_MAX] = {'\0'}; |
| 261 | if (!recordingPicture) { |
| 262 | property_get(PROPERTY_CAPTURE_SKP_FILENAME, prop, "0"); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 263 | recordingPicture = prop[0] != '0' && |
| 264 | mCapturedFile != prop; // ensure we capture only once per filename |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 265 | if (recordingPicture) { |
| 266 | mCapturedFile = prop; |
| 267 | mCaptureSequence = property_get_int32(PROPERTY_CAPTURE_SKP_FRAMES, 1); |
| 268 | } |
| 269 | } |
| 270 | if (recordingPicture) { |
| 271 | mRecorder.reset(new SkPictureRecorder()); |
| 272 | return mRecorder->beginRecording(surface->width(), surface->height(), nullptr, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 273 | SkPictureRecorder::kPlaybackDrawPicture_RecordFlag); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | return surface->getCanvas(); |
| 277 | } |
| 278 | |
| 279 | void SkiaPipeline::endCapture(SkSurface* surface) { |
| 280 | if (CC_UNLIKELY(mRecorder.get())) { |
| 281 | sk_sp<SkPicture> picture = mRecorder->finishRecordingAsPicture(); |
| 282 | surface->getCanvas()->drawPicture(picture); |
| 283 | if (picture->approximateOpCount() > 0) { |
Mike Reed | ebf96fb | 2017-12-13 13:43:16 -0500 | [diff] [blame] | 284 | auto data = picture->serialize(); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 285 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 286 | // offload saving to file in a different thread |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 287 | if (!mSavePictureProcessor.get()) { |
| 288 | TaskManager* taskManager = getTaskManager(); |
| 289 | mSavePictureProcessor = new SavePictureProcessor( |
| 290 | taskManager->canRunTasks() ? taskManager : nullptr); |
| 291 | } |
| 292 | if (1 == mCaptureSequence) { |
Mike Reed | ebf96fb | 2017-12-13 13:43:16 -0500 | [diff] [blame] | 293 | mSavePictureProcessor->savePicture(data, mCapturedFile); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 294 | } else { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 295 | mSavePictureProcessor->savePicture( |
Mike Reed | ebf96fb | 2017-12-13 13:43:16 -0500 | [diff] [blame] | 296 | data, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 297 | mCapturedFile + "_" + std::to_string(mCaptureSequence)); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 298 | } |
| 299 | mCaptureSequence--; |
| 300 | } |
| 301 | mRecorder.reset(); |
| 302 | } |
| 303 | } |
| 304 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 305 | void SkiaPipeline::renderFrame(const LayerUpdateQueue& layers, const SkRect& clip, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 306 | const std::vector<sp<RenderNode>>& nodes, bool opaque, |
| 307 | bool wideColorGamut, const Rect& contentDrawBounds, |
| 308 | sk_sp<SkSurface> surface) { |
Stan Iliev | 23c38a9 | 2017-03-23 00:12:50 -0400 | [diff] [blame] | 309 | renderVectorDrawableCache(); |
| 310 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 311 | // draw all layers up front |
Romain Guy | 07ae505 | 2017-06-13 18:25:32 -0700 | [diff] [blame] | 312 | renderLayersImpl(layers, opaque, wideColorGamut); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 313 | |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 314 | // initialize the canvas for the current frame, that might be a recording canvas if SKP |
| 315 | // capture is enabled. |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 316 | std::unique_ptr<SkPictureRecorder> recorder; |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 317 | SkCanvas* canvas = tryCapture(surface.get()); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 318 | |
Romain Guy | 07ae505 | 2017-06-13 18:25:32 -0700 | [diff] [blame] | 319 | renderFrameImpl(layers, clip, nodes, opaque, wideColorGamut, contentDrawBounds, canvas); |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 320 | |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 321 | endCapture(surface.get()); |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 322 | |
| 323 | if (CC_UNLIKELY(Properties::debugOverdraw)) { |
| 324 | renderOverdraw(layers, clip, nodes, contentDrawBounds, surface); |
| 325 | } |
| 326 | |
| 327 | ATRACE_NAME("flush commands"); |
Stan Iliev | e9d0012 | 2017-09-19 12:07:10 -0400 | [diff] [blame] | 328 | surface->getCanvas()->flush(); |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 329 | } |
| 330 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 331 | namespace { |
| 332 | static Rect nodeBounds(RenderNode& node) { |
| 333 | auto& props = node.properties(); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 334 | return Rect(props.getLeft(), props.getTop(), props.getRight(), props.getBottom()); |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 335 | } |
| 336 | } |
| 337 | |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 338 | void SkiaPipeline::renderFrameImpl(const LayerUpdateQueue& layers, const SkRect& clip, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 339 | const std::vector<sp<RenderNode>>& nodes, bool opaque, |
| 340 | bool wideColorGamut, const Rect& contentDrawBounds, |
| 341 | SkCanvas* canvas) { |
Stan Iliev | b66b8bb | 2016-12-15 18:17:42 -0500 | [diff] [blame] | 342 | SkAutoCanvasRestore saver(canvas, true); |
| 343 | canvas->androidFramework_setDeviceClipRestriction(clip.roundOut()); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 344 | |
Stan Iliev | aadc032 | 2018-03-23 10:50:11 -0400 | [diff] [blame^] | 345 | // STOPSHIP: Revert, temporary workaround to clear always F16 frame buffer for b/74976293 |
| 346 | if (!opaque || wideColorGamut) { |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 347 | canvas->clear(SK_ColorTRANSPARENT); |
| 348 | } |
| 349 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 350 | if (1 == nodes.size()) { |
| 351 | if (!nodes[0]->nothingToDraw()) { |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 352 | RenderNodeDrawable root(nodes[0].get(), canvas); |
| 353 | root.draw(canvas); |
| 354 | } |
| 355 | } else if (0 == nodes.size()) { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 356 | // nothing to draw |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 357 | } else { |
| 358 | // It there are multiple render nodes, they are laid out as follows: |
| 359 | // #0 - backdrop (content + caption) |
| 360 | // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop) |
| 361 | // #2 - additional overlay nodes |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 362 | // Usually the backdrop cannot be seen since it will be entirely covered by the content. |
| 363 | // While |
| 364 | // resizing however it might become partially visible. The following render loop will crop |
| 365 | // the |
| 366 | // backdrop against the content and draw the remaining part of it. It will then draw the |
| 367 | // content |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 368 | // cropped to the backdrop (since that indicates a shrinking of the window). |
| 369 | // |
| 370 | // Additional nodes will be drawn on top with no particular clipping semantics. |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 371 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 372 | // Usually the contents bounds should be mContentDrawBounds - however - we will |
| 373 | // move it towards the fixed edge to give it a more stable appearance (for the moment). |
| 374 | // If there is no content bounds we ignore the layering as stated above and start with 2. |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 375 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 376 | // Backdrop bounds in render target space |
| 377 | const Rect backdrop = nodeBounds(*nodes[0]); |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 378 | |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 379 | // Bounds that content will fill in render target space (note content node bounds may be |
| 380 | // bigger) |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 381 | Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight()); |
| 382 | content.translate(backdrop.left, backdrop.top); |
| 383 | if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) { |
| 384 | // Content doesn't entirely overlap backdrop, so fill around content (right/bottom) |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 385 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 386 | // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 387 | // also fill left/top. Currently, both 2up and freeform position content at the top/left |
| 388 | // of |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 389 | // the backdrop, so this isn't necessary. |
| 390 | RenderNodeDrawable backdropNode(nodes[0].get(), canvas); |
| 391 | if (content.right < backdrop.right) { |
| 392 | // draw backdrop to right side of content |
| 393 | SkAutoCanvasRestore acr(canvas, true); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 394 | canvas->clipRect(SkRect::MakeLTRB(content.right, backdrop.top, backdrop.right, |
| 395 | backdrop.bottom)); |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 396 | backdropNode.draw(canvas); |
| 397 | } |
| 398 | if (content.bottom < backdrop.bottom) { |
| 399 | // draw backdrop to bottom of content |
| 400 | // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill |
| 401 | SkAutoCanvasRestore acr(canvas, true); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 402 | canvas->clipRect(SkRect::MakeLTRB(content.left, content.bottom, content.right, |
| 403 | backdrop.bottom)); |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 404 | backdropNode.draw(canvas); |
| 405 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 406 | } |
| 407 | |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 408 | RenderNodeDrawable contentNode(nodes[1].get(), canvas); |
| 409 | if (!backdrop.isEmpty()) { |
| 410 | // content node translation to catch up with backdrop |
| 411 | float dx = backdrop.left - contentDrawBounds.left; |
| 412 | float dy = backdrop.top - contentDrawBounds.top; |
| 413 | |
| 414 | SkAutoCanvasRestore acr(canvas, true); |
| 415 | canvas->translate(dx, dy); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 416 | const SkRect contentLocalClip = |
| 417 | SkRect::MakeXYWH(contentDrawBounds.left, contentDrawBounds.top, |
| 418 | backdrop.getWidth(), backdrop.getHeight()); |
Stan Iliev | 5277127 | 2016-11-17 09:54:38 -0500 | [diff] [blame] | 419 | canvas->clipRect(contentLocalClip); |
| 420 | contentNode.draw(canvas); |
| 421 | } else { |
| 422 | SkAutoCanvasRestore acr(canvas, true); |
| 423 | contentNode.draw(canvas); |
| 424 | } |
| 425 | |
| 426 | // remaining overlay nodes, simply defer |
| 427 | for (size_t index = 2; index < nodes.size(); index++) { |
| 428 | if (!nodes[index]->nothingToDraw()) { |
| 429 | SkAutoCanvasRestore acr(canvas, true); |
| 430 | RenderNodeDrawable overlayNode(nodes[index].get(), canvas); |
| 431 | overlayNode.draw(canvas); |
| 432 | } |
| 433 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 434 | } |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 435 | } |
| 436 | |
Matt Sarett | 4bda6bf | 2016-11-07 15:43:41 -0500 | [diff] [blame] | 437 | void SkiaPipeline::dumpResourceCacheUsage() const { |
| 438 | int resources, maxResources; |
| 439 | size_t bytes, maxBytes; |
| 440 | mRenderThread.getGrContext()->getResourceCacheUsage(&resources, &bytes); |
| 441 | mRenderThread.getGrContext()->getResourceCacheLimits(&maxResources, &maxBytes); |
| 442 | |
| 443 | SkString log("Resource Cache Usage:\n"); |
| 444 | log.appendf("%8d items out of %d maximum items\n", resources, maxResources); |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 445 | log.appendf("%8zu bytes (%.2f MB) out of %.2f MB maximum\n", bytes, |
| 446 | bytes * (1.0f / (1024.0f * 1024.0f)), maxBytes * (1.0f / (1024.0f * 1024.0f))); |
Matt Sarett | 4bda6bf | 2016-11-07 15:43:41 -0500 | [diff] [blame] | 447 | |
| 448 | ALOGD("%s", log.c_str()); |
| 449 | } |
| 450 | |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 451 | // Overdraw debugging |
| 452 | |
| 453 | // These colors should be kept in sync with Caches::getOverdrawColor() with a few differences. |
| 454 | // This implementation: |
| 455 | // (1) Requires transparent entries for "no overdraw" and "single draws". |
| 456 | // (2) Requires premul colors (instead of unpremul). |
| 457 | // (3) Requires RGBA colors (instead of BGRA). |
| 458 | static const uint32_t kOverdrawColors[2][6] = { |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 459 | { |
| 460 | 0x00000000, 0x00000000, 0x2f2f0000, 0x2f002f00, 0x3f00003f, 0x7f00007f, |
| 461 | }, |
| 462 | { |
| 463 | 0x00000000, 0x00000000, 0x2f2f0000, 0x4f004f4f, 0x5f50335f, 0x7f00007f, |
| 464 | }, |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 465 | }; |
| 466 | |
| 467 | void SkiaPipeline::renderOverdraw(const LayerUpdateQueue& layers, const SkRect& clip, |
John Reck | 1bcacfd | 2017-11-03 10:12:19 -0700 | [diff] [blame] | 468 | const std::vector<sp<RenderNode>>& nodes, |
| 469 | const Rect& contentDrawBounds, sk_sp<SkSurface> surface) { |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 470 | // Set up the overdraw canvas. |
| 471 | SkImageInfo offscreenInfo = SkImageInfo::MakeA8(surface->width(), surface->height()); |
| 472 | sk_sp<SkSurface> offscreen = surface->makeSurface(offscreenInfo); |
| 473 | SkOverdrawCanvas overdrawCanvas(offscreen->getCanvas()); |
| 474 | |
| 475 | // Fake a redraw to replay the draw commands. This will increment the alpha channel |
| 476 | // each time a pixel would have been drawn. |
| 477 | // Pass true for opaque so we skip the clear - the overdrawCanvas is already zero |
| 478 | // initialized. |
Romain Guy | 07ae505 | 2017-06-13 18:25:32 -0700 | [diff] [blame] | 479 | renderFrameImpl(layers, clip, nodes, true, false, contentDrawBounds, &overdrawCanvas); |
Matt Sarett | f58cc92 | 2016-11-14 18:33:38 -0500 | [diff] [blame] | 480 | sk_sp<SkImage> counts = offscreen->makeImageSnapshot(); |
| 481 | |
| 482 | // Draw overdraw colors to the canvas. The color filter will convert counts to colors. |
| 483 | SkPaint paint; |
| 484 | const SkPMColor* colors = kOverdrawColors[static_cast<int>(Properties::overdrawColorSet)]; |
| 485 | paint.setColorFilter(SkOverdrawColorFilter::Make(colors)); |
| 486 | surface->getCanvas()->drawImage(counts.get(), 0.0f, 0.0f, &paint); |
| 487 | } |
| 488 | |
Stan Iliev | 500a0c3 | 2016-10-26 10:30:09 -0400 | [diff] [blame] | 489 | } /* namespace skiapipeline */ |
| 490 | } /* namespace uirenderer */ |
| 491 | } /* namespace android */ |