rngine 0.7.2 → 0.8.1

package/shared/skia/include/core/SkPictureRecorder.h

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPictureRecorder_DEFINED
+#define SkPictureRecorder_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/private/SkAPI.h"
+
+#include <memory>
+
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+namespace android {
+    class Picture;
+};
+#endif
+
+class SkBBHFactory;
+class SkBBoxHierarchy;
+class SkCanvas;
+class SkDrawable;
+class SkPicture;
+class SkRecord;
+class SkRecordCanvas;
+
+class SK_API SkPictureRecorder {
+public:
+    SkPictureRecorder();
+    ~SkPictureRecorder();
+
+    /** Returns the canvas that records the drawing commands.
+        @param bounds the cull rect used when recording this picture. Any drawing the falls outside
+                      of this rect is undefined, and may be drawn or it may not.
+        @param bbh         optional acceleration structure
+        @param recordFlags optional flags that control recording.
+        @return the canvas.
+    */
+    SkCanvas* beginRecording(const SkRect& bounds, sk_sp<SkBBoxHierarchy> bbh);
+
+    SkCanvas* beginRecording(const SkRect& bounds, SkBBHFactory* bbhFactory = nullptr);
+
+    SkCanvas* beginRecording(SkScalar width, SkScalar height,
+                             SkBBHFactory* bbhFactory = nullptr) {
+        return this->beginRecording(SkRect::MakeWH(width, height), bbhFactory);
+    }
+
+    /** Returns the recording canvas if one is active, or NULL if recording is
+        not active. This does not alter the refcnt on the canvas (if present).
+    */
+    SkCanvas* getRecordingCanvas();
+
+    /**
+     *  Signal that the caller is done recording. This invalidates the canvas returned by
+     *  beginRecording/getRecordingCanvas. Ownership of the object is passed to the caller, who
+     *  must call unref() when they are done using it.
+     *
+     *  The returned picture is immutable. If during recording drawables were added to the canvas,
+     *  these will have been "drawn" into a recording canvas, so that this resulting picture will
+     *  reflect their current state, but will not contain a live reference to the drawables
+     *  themselves.
+     */
+    sk_sp<SkPicture> finishRecordingAsPicture();
+
+    /**
+     *  Signal that the caller is done recording, and update the cull rect to use for bounding
+     *  box hierarchy (BBH) generation. The behavior is the same as calling
+     *  finishRecordingAsPicture(), except that this method updates the cull rect initially passed
+     *  into beginRecording.
+     *  @param cullRect the new culling rectangle to use as the overall bound for BBH generation
+     *                  and subsequent culling operations.
+     *  @return the picture containing the recorded content.
+     */
+    sk_sp<SkPicture> finishRecordingAsPictureWithCull(const SkRect& cullRect);
+
+    /**
+     *  Signal that the caller is done recording. This invalidates the canvas returned by
+     *  beginRecording/getRecordingCanvas. Ownership of the object is passed to the caller, who
+     *  must call unref() when they are done using it.
+     *
+     *  Unlike finishRecordingAsPicture(), which returns an immutable picture, the returned drawable
+     *  may contain live references to other drawables (if they were added to the recording canvas)
+     *  and therefore this drawable will reflect the current state of those nested drawables anytime
+     *  it is drawn or a new picture is snapped from it (by calling drawable->makePictureSnapshot()).
+     */
+    sk_sp<SkDrawable> finishRecordingAsDrawable();
+
+private:
+    void reset();
+
+    /** Replay the current (partially recorded) operation stream into
+        canvas. This call doesn't close the current recording.
+    */
+#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
+    friend class android::Picture;
+#endif
+    friend class SkPictureRecorderReplayTester; // for unit testing
+    void partialReplay(SkCanvas* canvas) const;
+
+    sk_sp<SkBBoxHierarchy> fBBH;
+    std::unique_ptr<SkRecordCanvas> fRecorder;
+    sk_sp<SkRecord> fRecord;
+    SkRect fCullRect;
+    bool fActivelyRecording;
+
+    SkPictureRecorder(SkPictureRecorder&&) = delete;
+    SkPictureRecorder& operator=(SkPictureRecorder&&) = delete;
+};
+
+#endif

package/shared/skia/include/core/SkPixelRef.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2008 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPixelRef_DEFINED
+#define SkPixelRef_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkIDChangeListener.h"
+#include "include/private/SkPixelStorage.h"
+#include "include/private/SkTo.h"
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+
+class SkDiscardableMemory;
+
+/** \class SkPixelRef
+
+    This class is the smart container for pixel memory, and is used with SkBitmap.
+    This class can be shared/accessed between multiple threads.
+*/
+class SK_API SkPixelRef : public SkPixelStorage {
+public:
+    SkPixelRef(int width, int height, void* addr, size_t rowBytes);
+    ~SkPixelRef() override;
+
+    SkISize dimensions() const { return {fWidth, fHeight}; }
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+    void* pixels() const { return fPixels; }
+    size_t rowBytes() const { return fRowBytes; }
+
+    /** Returns a non-zero, unique value corresponding to the pixels in this
+        pixelref. Each time the pixels are changed (and notifyPixelsChanged is
+        called), a different generation ID will be returned.
+    */
+    uint32_t getGenerationID() const;
+
+    /**
+     *  Call this if you have changed the contents of the pixels. This will in-
+     *  turn cause a different generation ID value to be returned from
+     *  getGenerationID().
+     */
+    void notifyPixelsChanged();
+
+    /** Returns true if this pixelref is marked as immutable, meaning that the
+        contents of its pixels will not change for the lifetime of the pixelref.
+    */
+    bool isImmutable() const { return fMutability != kMutable; }
+
+    /** Marks this pixelref is immutable, meaning that the contents of its
+        pixels will not change for the lifetime of the pixelref. This state can
+        be set on a pixelref, but it cannot be cleared once it is set.
+    */
+    void setImmutable();
+
+    // Register a listener that may be called the next time our generation ID changes.
+    //
+    // We'll only call the listener if we're confident that we are the only SkPixelRef with this
+    // generation ID.  If our generation ID changes and we decide not to call the listener, we'll
+    // never call it: you must add a new listener for each generation ID change.  We also won't call
+    // the listener when we're certain no one knows what our generation ID is.
+    //
+    // This can be used to invalidate caches keyed by SkPixelRef generation ID.
+    // Takes ownership of listener.  Threadsafe.
+    void addGenIDChangeListener(sk_sp<SkIDChangeListener> listener);
+
+    // Call when this pixelref is part of the key to a resourcecache entry. This allows the cache
+    // to know automatically those entries can be purged when this pixelref is changed or deleted.
+    void notifyAddedToCache() {
+        fAddedToCache.store(true);
+    }
+
+    virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return nullptr; }
+
+protected:
+    void android_only_reset(int width, int height, size_t rowBytes);
+
+private:
+    int                 fWidth;
+    int                 fHeight;
+    void*               fPixels;
+    size_t              fRowBytes;
+
+    // Bottom bit indicates the Gen ID is unique.
+    bool genIDIsUnique() const { return SkToBool(fTaggedGenID.load() & 1); }
+    mutable std::atomic<uint32_t> fTaggedGenID;
+
+    SkIDChangeListener::List fGenIDChangeListeners;
+
+    // Set true by caches when they cache content that's derived from the current pixels.
+    std::atomic<bool> fAddedToCache;
+
+    enum Mutability {
+        kMutable,               // PixelRefs begin mutable.
+        kTemporarilyImmutable,  // Considered immutable, but can revert to mutable.
+        kImmutable,             // Once set to this state, it never leaves.
+    } fMutability : 8;          // easily fits inside a byte
+
+    void needsNewGenID();
+    void callGenIDChangeListeners();
+
+    void setTemporarilyImmutable();
+    void restoreMutability();
+    friend class SkSurface_Raster;  // For temporary immutable methods above.
+
+    void setImmutableWithID(uint32_t genID);
+    friend void SkBitmapCache_setImmutableWithID(SkPixelRef*, uint32_t);
+
+    using INHERITED = SkRefCnt;
+};
+
+#endif