libs/hwui/RecordingCanvas.h

   1 /*
   2  * Copyright (C) 2015 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 #ifndef ANDROID_HWUI_RECORDING_CANVAS_H
  18 #define ANDROID_HWUI_RECORDING_CANVAS_H
  19
  20 #include "CanvasState.h"
  21 #include "DisplayList.h"
  22 #include "ResourceCache.h"
  23 #include "SkiaCanvasProxy.h"
  24 #include "Snapshot.h"
  25 #include "hwui/Canvas.h"
  26 #include "utils/LinearAllocator.h"
  27 #include "utils/Macros.h"
  28 #include "utils/NinePatch.h"
  29
  30 #include <SkDrawFilter.h>
  31 #include <SkPaint.h>
  32 #include <SkTLazy.h>
  33
  34 #include <vector>
  35
  36 namespace android {
  37 namespace uirenderer {
  38
  39 struct ClipBase;
  40 class DeferredLayerUpdater;
  41 struct RecordedOp;
  42
  43 class ANDROID_API RecordingCanvas: public Canvas, public CanvasStateClient {
  44     enum class DeferredBarrierType {
  45         None,
  46         InOrder,
  47         OutOfOrder,
  48     };
  49 public:
  50     RecordingCanvas(size_t width, size_t height);
  51     virtual ~RecordingCanvas();
  52
  53     virtual void resetRecording(int width, int height) override;
  54     virtual WARN_UNUSED_RESULT DisplayList* finishRecording() override;
  55 // ----------------------------------------------------------------------------
  56 // MISC HWUI OPERATIONS - TODO: CATEGORIZE
  57 // ----------------------------------------------------------------------------
  58     virtual void insertReorderBarrier(bool enableReorder) override;
  59
  60     virtual void drawLayer(DeferredLayerUpdater* layerHandle) override;
  61     virtual void drawRenderNode(RenderNode* renderNode) override;
  62     virtual void callDrawGLFunction(Functor* functor,
  63             GlFunctorLifecycleListener* listener) override;
  64
  65 // ----------------------------------------------------------------------------
  66 // CanvasStateClient interface
  67 // ----------------------------------------------------------------------------
  68     virtual void onViewportInitialized() override;
  69     virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) override;
  70     virtual GLuint getTargetFbo() const override { return -1; }
  71
  72 // ----------------------------------------------------------------------------
  73 // HWUI Canvas draw operations
  74 // ----------------------------------------------------------------------------
  75
  76     virtual void drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
  77             CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
  78             CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
  79             CanvasPropertyPaint* paint) override;
  80     virtual void drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
  81             CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) override;
  82
  83 // ----------------------------------------------------------------------------
  84 // android/graphics/Canvas interface
  85 // ----------------------------------------------------------------------------
  86     virtual SkCanvas* asSkCanvas() override;
  87
  88     virtual void setBitmap(const SkBitmap& bitmap) override {
  89         LOG_ALWAYS_FATAL("RecordingCanvas is not backed by a bitmap.");
  90     }
  91
  92     virtual bool isOpaque() override { return false; }
  93     virtual int width() override { return mState.getWidth(); }
  94     virtual int height() override { return mState.getHeight(); }
  95
  96     virtual void setHighContrastText(bool highContrastText) override {
  97         mHighContrastText = highContrastText;
  98     }
  99     virtual bool isHighContrastText() override { return mHighContrastText; }
 100
 101 // ----------------------------------------------------------------------------
 102 // android/graphics/Canvas state operations
 103 // ----------------------------------------------------------------------------
 104     // Save (layer)
 105     virtual int getSaveCount() const override { return mState.getSaveCount(); }
 106     virtual int save(SaveFlags::Flags flags) override;
 107     virtual void restore() override;
 108     virtual void restoreToCount(int saveCount) override;
 109
 110     virtual int saveLayer(float left, float top, float right, float bottom, const SkPaint* paint,
 111         SaveFlags::Flags flags) override;
 112     virtual int saveLayerAlpha(float left, float top, float right, float bottom,
 113             int alpha, SaveFlags::Flags flags) override {
 114         SkPaint paint;
 115         paint.setAlpha(alpha);
 116         return saveLayer(left, top, right, bottom, &paint, flags);
 117     }
 118
 119     // Matrix
 120     virtual void getMatrix(SkMatrix* outMatrix) const override { mState.getMatrix(outMatrix); }
 121     virtual void setMatrix(const SkMatrix& matrix) override { mState.setMatrix(matrix); }
 122
 123     virtual void concat(const SkMatrix& matrix) override { mState.concatMatrix(matrix); }
 124     virtual void rotate(float degrees) override;
 125     virtual void scale(float sx, float sy) override;
 126     virtual void skew(float sx, float sy) override;
 127     virtual void translate(float dx, float dy) override;
 128
 129     // Clip
 130     virtual bool getClipBounds(SkRect* outRect) const override;
 131     virtual bool quickRejectRect(float left, float top, float right, float bottom) const override;
 132     virtual bool quickRejectPath(const SkPath& path) const override;
 133
 134     virtual bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op) override;
 135     virtual bool clipPath(const SkPath* path, SkRegion::Op op) override;
 136     virtual bool clipRegion(const SkRegion* region, SkRegion::Op op) override;
 137
 138     // Misc
 139     virtual SkDrawFilter* getDrawFilter() override { return mDrawFilter.get(); }
 140     virtual void setDrawFilter(SkDrawFilter* filter) override {
 141         mDrawFilter.reset(SkSafeRef(filter));
 142     }
 143
 144 // ----------------------------------------------------------------------------
 145 // android/graphics/Canvas draw operations
 146 // ----------------------------------------------------------------------------
 147     virtual void drawColor(int color, SkXfermode::Mode mode) override;
 148     virtual void drawPaint(const SkPaint& paint) override;
 149
 150     // Geometry
 151     virtual void drawPoint(float x, float y, const SkPaint& paint) override {
 152         float points[2] = { x, y };
 153         drawPoints(points, 2, paint);
 154     }
 155     virtual void drawPoints(const float* points, int floatCount, const SkPaint& paint) override;
 156     virtual void drawLine(float startX, float startY, float stopX, float stopY,
 157             const SkPaint& paint) override {
 158         float points[4] = { startX, startY, stopX, stopY };
 159         drawLines(points, 4, paint);
 160     }
 161     virtual void drawLines(const float* points, int floatCount, const SkPaint& paint) override;
 162     virtual void drawRect(float left, float top, float right, float bottom, const SkPaint& paint) override;
 163     virtual void drawRegion(const SkRegion& region, const SkPaint& paint) override;
 164     virtual void drawRoundRect(float left, float top, float right, float bottom,
 165             float rx, float ry, const SkPaint& paint) override;
 166     virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) override;
 167     virtual void drawOval(float left, float top, float right, float bottom, const SkPaint& paint) override;
 168     virtual void drawArc(float left, float top, float right, float bottom,
 169             float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) override;
 170     virtual void drawPath(const SkPath& path, const SkPaint& paint) override;
 171     virtual void drawVertices(SkCanvas::VertexMode vertexMode, int vertexCount,
 172             const float* verts, const float* tex, const int* colors,
 173             const uint16_t* indices, int indexCount, const SkPaint& paint) override
 174         { /* RecordingCanvas does not support drawVertices(); ignore */ }
 175
 176     virtual void drawVectorDrawable(VectorDrawableRoot* tree) override;
 177
 178     // Bitmap-based
 179     virtual void drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) override;
 180     virtual void drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
 181                             const SkPaint* paint) override;
 182     virtual void drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,
 183             float srcRight, float srcBottom, float dstLeft, float dstTop,
 184             float dstRight, float dstBottom, const SkPaint* paint) override;
 185     virtual void drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
 186             const float* vertices, const int* colors, const SkPaint* paint) override;
 187     virtual void drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
 188             float dstLeft, float dstTop, float dstRight, float dstBottom,
 189             const SkPaint* paint) override;
 190
 191     // Text
 192     virtual bool drawTextAbsolutePos() const override { return false; }
 193
 194 protected:
 195     virtual void drawGlyphs(const uint16_t* text, const float* positions, int count,
 196             const SkPaint& paint, float x, float y,
 197             float boundsLeft, float boundsTop, float boundsRight, float boundsBottom,
 198             float totalAdvance) override;
 199     virtual void drawGlyphsOnPath(const uint16_t* glyphs, int count, const SkPath& path,
 200             float hOffset, float vOffset, const SkPaint& paint) override;
 201
 202 private:
 203     const ClipBase* getRecordedClip() {
 204         return mState.writableSnapshot()->mutateClipArea().serializeClip(alloc());
 205     }
 206
 207     void drawBitmap(const SkBitmap* bitmap, const SkPaint* paint);
 208     void drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint);
 209
 210
 211     int addOp(RecordedOp* op);
 212 // ----------------------------------------------------------------------------
 213 // lazy object copy
 214 // ----------------------------------------------------------------------------
 215     LinearAllocator& alloc() { return mDisplayList->allocator; }
 216
 217     void refBitmapsInShader(const SkShader* shader);
 218
 219     template<class T>
 220     inline const T* refBuffer(const T* srcBuffer, int32_t count) {
 221         if (!srcBuffer) return nullptr;
 222
 223         T* dstBuffer = (T*) mDisplayList->allocator.alloc<T>(count * sizeof(T));
 224         memcpy(dstBuffer, srcBuffer, count * sizeof(T));
 225         return dstBuffer;
 226     }
 227
 228     inline const SkPath* refPath(const SkPath* path) {
 229         if (!path) return nullptr;
 230
 231         // The points/verbs within the path are refcounted so this copy operation
 232         // is inexpensive and maintains the generationID of the original path.
 233         const SkPath* cachedPath = new SkPath(*path);
 234         mDisplayList->pathResources.push_back(cachedPath);
 235         return cachedPath;
 236     }
 237
 238     /**
 239      * Returns a RenderThread-safe, const copy of the SkPaint parameter passed in
 240      * (with deduping based on paint hash / equality check)
 241      */
 242     inline const SkPaint* refPaint(const SkPaint* paint) {
 243         if (!paint) return nullptr;
 244
 245         // If there is a draw filter apply it here and store the modified paint
 246         // so that we don't need to modify the paint every time we access it.
 247         SkTLazy<SkPaint> filteredPaint;
 248         if (mDrawFilter.get()) {
 249             filteredPaint.set(*paint);
 250             mDrawFilter->filter(filteredPaint.get(), SkDrawFilter::kPaint_Type);
 251             paint = filteredPaint.get();
 252         }
 253
 254         // compute the hash key for the paint and check the cache.
 255         const uint32_t key = paint->getHash();
 256         const SkPaint* cachedPaint = mPaintMap.valueFor(key);
 257         // In the unlikely event that 2 unique paints have the same hash we do a
 258         // object equality check to ensure we don't erroneously dedup them.
 259         if (cachedPaint == nullptr || *cachedPaint != *paint) {
 260             cachedPaint = new SkPaint(*paint);
 261             mDisplayList->paints.emplace_back(cachedPaint);
 262             // replaceValueFor() performs an add if the entry doesn't exist
 263             mPaintMap.replaceValueFor(key, cachedPaint);
 264             refBitmapsInShader(cachedPaint->getShader());
 265         }
 266
 267         return cachedPaint;
 268     }
 269
 270     inline const SkRegion* refRegion(const SkRegion* region) {
 271         if (!region) {
 272             return region;
 273         }
 274
 275         const SkRegion* cachedRegion = mRegionMap.valueFor(region);
 276         // TODO: Add generation ID to SkRegion
 277         if (cachedRegion == nullptr) {
 278             std::unique_ptr<const SkRegion> copy(new SkRegion(*region));
 279             cachedRegion = copy.get();
 280             mDisplayList->regions.push_back(std::move(copy));
 281
 282             // replaceValueFor() performs an add if the entry doesn't exist
 283             mRegionMap.replaceValueFor(region, cachedRegion);
 284         }
 285
 286         return cachedRegion;
 287     }
 288
 289     inline const SkBitmap* refBitmap(const SkBitmap& bitmap) {
 290         // Note that this assumes the bitmap is immutable. There are cases this won't handle
 291         // correctly, such as creating the bitmap from scratch, drawing with it, changing its
 292         // contents, and drawing again. The only fix would be to always copy it the first time,
 293         // which doesn't seem worth the extra cycles for this unlikely case.
 294         SkBitmap* localBitmap = alloc().create<SkBitmap>(bitmap);
 295         mDisplayList->bitmapResources.push_back(localBitmap);
 296         return localBitmap;
 297     }
 298
 299     inline const Res_png_9patch* refPatch(const Res_png_9patch* patch) {
 300         mDisplayList->patchResources.push_back(patch);
 301         mResourceCache.incrementRefcount(patch);
 302         return patch;
 303     }
 304
 305     DefaultKeyedVector<uint32_t, const SkPaint*> mPaintMap;
 306     DefaultKeyedVector<const SkPath*, const SkPath*> mPathMap;
 307     DefaultKeyedVector<const SkRegion*, const SkRegion*> mRegionMap;
 308
 309     CanvasState mState;
 310     std::unique_ptr<SkiaCanvasProxy> mSkiaCanvasProxy;
 311     ResourceCache& mResourceCache;
 312     DeferredBarrierType mDeferredBarrierType = DeferredBarrierType::None;
 313     const ClipBase* mDeferredBarrierClip = nullptr;
 314     DisplayList* mDisplayList = nullptr;
 315     bool mHighContrastText = false;
 316     SkAutoTUnref<SkDrawFilter> mDrawFilter;
 317 }; // class RecordingCanvas
 318
 319 }; // namespace uirenderer
 320 }; // namespace android
 321
 322 #endif // ANDROID_HWUI_RECORDING_CANVAS_H