SkiaRecordingCanvas.cpp revision ee708facf127f2e8bed5970d5c05fa823fcfc1ce
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 "SkiaRecordingCanvas.h" 18 19#include "Layer.h" 20#include "RenderNode.h" 21#include "LayerDrawable.h" 22#include "NinePatchUtils.h" 23#include "pipeline/skia/AnimatedDrawables.h" 24#include <SkImagePriv.h> 25 26namespace android { 27namespace uirenderer { 28namespace skiapipeline { 29 30// ---------------------------------------------------------------------------- 31// Recording Canvas Setup 32// ---------------------------------------------------------------------------- 33 34void SkiaRecordingCanvas::initDisplayList(uirenderer::RenderNode* renderNode, int width, 35 int height) { 36 mCurrentBarrier = nullptr; 37 SkASSERT(mDisplayList.get() == nullptr); 38 39 if (renderNode) { 40 mDisplayList = renderNode->detachAvailableList(); 41 } 42 SkRect bounds = SkRect::MakeWH(width, height); 43 if (mDisplayList) { 44 mDisplayList->reset(bounds); 45 } else { 46 mDisplayList.reset(new SkiaDisplayList(bounds)); 47 } 48 49 mRecorder.reset(mDisplayList->mDrawable.get()); 50 SkiaCanvas::reset(&mRecorder); 51} 52 53uirenderer::DisplayList* SkiaRecordingCanvas::finishRecording() { 54 // close any existing chunks if necessary 55 insertReorderBarrier(false); 56 mRecorder.restoreToCount(1); 57 return mDisplayList.release(); 58} 59 60// ---------------------------------------------------------------------------- 61// Recording Canvas draw operations: View System 62// ---------------------------------------------------------------------------- 63 64void SkiaRecordingCanvas::drawRoundRect(uirenderer::CanvasPropertyPrimitive* left, 65 uirenderer::CanvasPropertyPrimitive* top, uirenderer::CanvasPropertyPrimitive* right, 66 uirenderer::CanvasPropertyPrimitive* bottom, uirenderer::CanvasPropertyPrimitive* rx, 67 uirenderer::CanvasPropertyPrimitive* ry, uirenderer::CanvasPropertyPaint* paint) { 68 drawDrawable(mDisplayList->allocateDrawable<AnimatedRoundRect>(left, top, right, bottom, 69 rx, ry, paint)); 70} 71 72void SkiaRecordingCanvas::drawCircle(uirenderer::CanvasPropertyPrimitive* x, 73 uirenderer::CanvasPropertyPrimitive* y, uirenderer::CanvasPropertyPrimitive* radius, 74 uirenderer::CanvasPropertyPaint* paint) { 75 drawDrawable(mDisplayList->allocateDrawable<AnimatedCircle>(x, y, radius, paint)); 76} 77 78void SkiaRecordingCanvas::insertReorderBarrier(bool enableReorder) { 79 if (nullptr != mCurrentBarrier) { 80 // finish off the existing chunk 81 SkDrawable* drawable = 82 mDisplayList->allocateDrawable<EndReorderBarrierDrawable>( 83 mCurrentBarrier); 84 mCurrentBarrier = nullptr; 85 drawDrawable(drawable); 86 } 87 if (enableReorder) { 88 mCurrentBarrier = (StartReorderBarrierDrawable*) 89 mDisplayList->allocateDrawable<StartReorderBarrierDrawable>( 90 mDisplayList.get()); 91 drawDrawable(mCurrentBarrier); 92 } 93} 94 95void SkiaRecordingCanvas::drawLayer(uirenderer::DeferredLayerUpdater* layerUpdater) { 96 if (layerUpdater != nullptr && layerUpdater->backingLayer() != nullptr) { 97 uirenderer::Layer* layer = layerUpdater->backingLayer(); 98 sk_sp<SkDrawable> drawable(new LayerDrawable(layer)); 99 drawDrawable(drawable.get()); 100 } 101} 102 103void SkiaRecordingCanvas::drawRenderNode(uirenderer::RenderNode* renderNode) { 104 // record the child node 105 mDisplayList->mChildNodes.emplace_back(renderNode, asSkCanvas(), true, mCurrentBarrier); 106 auto& renderNodeDrawable = mDisplayList->mChildNodes.back(); 107 drawDrawable(&renderNodeDrawable); 108 109 // use staging property, since recording on UI thread 110 if (renderNode->stagingProperties().isProjectionReceiver()) { 111 mDisplayList->mProjectionReceiver = &renderNodeDrawable; 112 // set projectionReceiveIndex so that RenderNode.hasProjectionReceiver returns true 113 mDisplayList->projectionReceiveIndex = mDisplayList->mChildNodes.size() - 1; 114 } 115} 116 117void SkiaRecordingCanvas::callDrawGLFunction(Functor* functor, 118 uirenderer::GlFunctorLifecycleListener* listener) { 119 mDisplayList->mChildFunctors.emplace_back(functor, listener, asSkCanvas()); 120 drawDrawable(&mDisplayList->mChildFunctors.back()); 121} 122 123class VectorDrawable : public SkDrawable { 124 public: 125 VectorDrawable(VectorDrawableRoot* tree) : mRoot(tree) {} 126 127 protected: 128 virtual SkRect onGetBounds() override { 129 return SkRect::MakeLargest(); 130 } 131 virtual void onDraw(SkCanvas* canvas) override { 132 Bitmap& hwuiBitmap = mRoot->getBitmapUpdateIfDirty(); 133 SkBitmap bitmap; 134 hwuiBitmap.getSkBitmap(&bitmap); 135 SkPaint* paint = mRoot->getPaint(); 136 canvas->drawBitmapRect(bitmap, mRoot->mutateProperties()->getBounds(), paint); 137 /* 138 * TODO we can draw this directly but need to address the following... 139 * 140 * 1) Add drawDirect(SkCanvas*) to VectorDrawableRoot 141 * 2) fix VectorDrawable.cpp's Path::draw to not make a temporary path 142 * so that we don't break caching 143 * 3) figure out how to set path's as volatile during animation 144 * 4) if mRoot->getPaint() != null either promote to layer (during 145 * animation) or cache in SkSurface (for static content) 146 * 147 */ 148 } 149 150 private: 151 sp<VectorDrawableRoot> mRoot; 152}; 153 154void SkiaRecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) { 155 drawDrawable(mDisplayList->allocateDrawable<VectorDrawable>(tree)); 156 mDisplayList->mVectorDrawables.push_back(tree); 157} 158 159// ---------------------------------------------------------------------------- 160// Recording Canvas draw operations: Bitmaps 161// ---------------------------------------------------------------------------- 162 163inline static const SkPaint* nonAAPaint(const SkPaint* origPaint, SkPaint* tmpPaint) { 164 if (origPaint && origPaint->isAntiAlias()) { 165 *tmpPaint = *origPaint; 166 tmpPaint->setAntiAlias(false); 167 return tmpPaint; 168 } else { 169 return origPaint; 170 } 171} 172 173void SkiaRecordingCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) { 174 SkBitmap skBitmap; 175 bitmap.getSkBitmap(&skBitmap); 176 177 sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(skBitmap, kNever_SkCopyPixelsMode); 178 if (!skBitmap.isImmutable()) { 179 mDisplayList->mMutableImages.push_back(image.get()); 180 } 181 SkPaint tmpPaint; 182 mRecorder.drawImage(image, left, top, nonAAPaint(paint, &tmpPaint)); 183} 184 185void SkiaRecordingCanvas::drawBitmap(Bitmap& hwuiBitmap, const SkMatrix& matrix, 186 const SkPaint* paint) { 187 SkBitmap bitmap; 188 hwuiBitmap.getSkBitmap(&bitmap); 189 SkAutoCanvasRestore acr(&mRecorder, true); 190 concat(matrix); 191 sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode); 192 if (!bitmap.isImmutable()) { 193 mDisplayList->mMutableImages.push_back(image.get()); 194 } 195 SkPaint tmpPaint; 196 mRecorder.drawImage(image, 0, 0, nonAAPaint(paint, &tmpPaint)); 197} 198 199void SkiaRecordingCanvas::drawBitmap(Bitmap& hwuiBitmap, float srcLeft, float srcTop, 200 float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight, 201 float dstBottom, const SkPaint* paint) { 202 SkBitmap bitmap; 203 hwuiBitmap.getSkBitmap(&bitmap); 204 SkRect srcRect = SkRect::MakeLTRB(srcLeft, srcTop, srcRight, srcBottom); 205 SkRect dstRect = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom); 206 sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode); 207 if (!bitmap.isImmutable()) { 208 mDisplayList->mMutableImages.push_back(image.get()); 209 } 210 SkPaint tmpPaint; 211 mRecorder.drawImageRect(image, srcRect, dstRect, nonAAPaint(paint, &tmpPaint)); 212} 213 214void SkiaRecordingCanvas::drawNinePatch(Bitmap& hwuiBitmap, const Res_png_9patch& chunk, 215 float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) { 216 SkBitmap bitmap; 217 hwuiBitmap.getSkBitmap(&bitmap); 218 219 SkCanvas::Lattice lattice; 220 NinePatchUtils::SetLatticeDivs(&lattice, chunk, bitmap.width(), bitmap.height()); 221 222 lattice.fFlags = nullptr; 223 int numFlags = 0; 224 if (chunk.numColors > 0 && chunk.numColors == NinePatchUtils::NumDistinctRects(lattice)) { 225 // We can expect the framework to give us a color for every distinct rect. 226 // Skia requires placeholder flags for degenerate rects. 227 numFlags = (lattice.fXCount + 1) * (lattice.fYCount + 1); 228 } 229 230 SkAutoSTMalloc<25, SkCanvas::Lattice::Flags> flags(numFlags); 231 if (numFlags > 0) { 232 NinePatchUtils::SetLatticeFlags(&lattice, flags.get(), numFlags, chunk); 233 } 234 235 lattice.fBounds = nullptr; 236 SkRect dst = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom); 237 sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode); 238 if (!bitmap.isImmutable()) { 239 mDisplayList->mMutableImages.push_back(image.get()); 240 } 241 242 SkPaint tmpPaint; 243 mRecorder.drawImageLattice(image.get(), lattice, dst, nonAAPaint(paint, &tmpPaint)); 244} 245 246}; // namespace skiapipeline 247}; // namespace uirenderer 248}; // namespace android 249