@shopify/react-native-skia 0.0.135

package/cpp/skia/include/core/SkDrawLooper.h

@@ -0,0 +1,135 @@
+
+/*
+ * Copyright 2011 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 SkDrawLooper_DEFINED
+#define SkDrawLooper_DEFINED
+
+#include "include/core/SkBlurTypes.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkFlattenable.h"
+#include "include/core/SkPoint.h"
+#include <functional>  // std::function
+
+#ifndef SK_SUPPORT_LEGACY_DRAWLOOPER
+#error "SkDrawLooper is unsupported"
+#endif
+
+class  SkArenaAlloc;
+class  SkCanvas;
+class  SkMatrix;
+class  SkPaint;
+struct SkRect;
+
+/** \class SkDrawLooper
+    DEPRECATED: No longer supported in Skia.
+*/
+class SK_API SkDrawLooper : public SkFlattenable {
+public:
+    /**
+     *  Holds state during a draw. Users call next() until it returns false.
+     *
+     *  Subclasses of SkDrawLooper should create a subclass of this object to
+     *  hold state specific to their subclass.
+     */
+    class SK_API Context {
+    public:
+        Context() {}
+        virtual ~Context() {}
+
+        struct Info {
+            SkVector fTranslate;
+            bool     fApplyPostCTM;
+
+            void applyToCTM(SkMatrix* ctm) const;
+            void applyToCanvas(SkCanvas*) const;
+        };
+
+        /**
+         *  Called in a loop on objects returned by SkDrawLooper::createContext().
+         *  Each time true is returned, the object is drawn (possibly with a modified
+         *  canvas and/or paint). When false is finally returned, drawing for the object
+         *  stops.
+         *
+         *  On each call, the paint will be in its original state, but the
+         *  canvas will be as it was following the previous call to next() or
+         *  createContext().
+         *
+         *  The implementation must ensure that, when next() finally returns
+         *  false, the canvas has been restored to the state it was
+         *  initially, before createContext() was first called.
+         */
+        virtual bool next(Info*, SkPaint*) = 0;
+
+    private:
+        Context(const Context&) = delete;
+        Context& operator=(const Context&) = delete;
+    };
+
+    /**
+     *  Called right before something is being drawn. Returns a Context
+     *  whose next() method should be called until it returns false.
+     */
+    virtual Context* makeContext(SkArenaAlloc*) const = 0;
+
+    /**
+     * The fast bounds functions are used to enable the paint to be culled early
+     * in the drawing pipeline. If a subclass can support this feature it must
+     * return true for the canComputeFastBounds() function.  If that function
+     * returns false then computeFastBounds behavior is undefined otherwise it
+     * is expected to have the following behavior. Given the parent paint and
+     * the parent's bounding rect the subclass must fill in and return the
+     * storage rect, where the storage rect is with the union of the src rect
+     * and the looper's bounding rect.
+     */
+    bool canComputeFastBounds(const SkPaint& paint) const;
+    void computeFastBounds(const SkPaint& paint, const SkRect& src, SkRect* dst) const;
+
+    struct BlurShadowRec {
+        SkScalar        fSigma;
+        SkVector        fOffset;
+        SkColor         fColor;
+        SkBlurStyle     fStyle;
+    };
+    /**
+     *  If this looper can be interpreted as having two layers, such that
+     *      1. The first layer (bottom most) just has a blur and translate
+     *      2. The second layer has no modifications to either paint or canvas
+     *      3. No other layers.
+     *  then return true, and if not null, fill out the BlurShadowRec).
+     *
+     *  If any of the above are not met, return false and ignore the BlurShadowRec parameter.
+     */
+    virtual bool asABlurShadow(BlurShadowRec*) const;
+
+    static SkFlattenable::Type GetFlattenableType() {
+        return kSkDrawLooper_Type;
+    }
+
+    SkFlattenable::Type getFlattenableType() const override {
+        return kSkDrawLooper_Type;
+    }
+
+    static sk_sp<SkDrawLooper> Deserialize(const void* data, size_t size,
+                                          const SkDeserialProcs* procs = nullptr) {
+        return sk_sp<SkDrawLooper>(static_cast<SkDrawLooper*>(
+                                  SkFlattenable::Deserialize(
+                                  kSkDrawLooper_Type, data, size, procs).release()));
+    }
+
+    void apply(SkCanvas* canvas, const SkPaint& paint,
+               std::function<void(SkCanvas*, const SkPaint&)>);
+
+protected:
+    SkDrawLooper() {}
+
+private:
+    using INHERITED = SkFlattenable;
+};
+
+#endif

package/cpp/skia/include/core/SkDrawable.h

@@ -0,0 +1,167 @@
+/*
+ * 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 SkDrawable_DEFINED
+#define SkDrawable_DEFINED
+
+#include "include/core/SkFlattenable.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkScalar.h"
+
+class GrBackendDrawableInfo;
+class SkCanvas;
+class SkMatrix;
+class SkPicture;
+enum class GrBackendApi : unsigned;
+struct SkRect;
+
+/**
+ *  Base-class for objects that draw into SkCanvas.
+ *
+ *  The object has a generation ID, which is guaranteed to be unique across all drawables. To
+ *  allow for clients of the drawable that may want to cache the results, the drawable must
+ *  change its generation ID whenever its internal state changes such that it will draw differently.
+ */
+class SK_API SkDrawable : public SkFlattenable {
+public:
+    /**
+     *  Draws into the specified content. The drawing sequence will be balanced upon return
+     *  (i.e. the saveLevel() on the canvas will match what it was when draw() was called,
+     *  and the current matrix and clip settings will not be changed.
+     */
+    void draw(SkCanvas*, const SkMatrix* = nullptr);
+    void draw(SkCanvas*, SkScalar x, SkScalar y);
+
+    /**
+     *  When using the GPU backend it is possible for a drawable to execute using the underlying 3D
+     *  API rather than the SkCanvas API. It does so by creating a GpuDrawHandler. The GPU backend
+     *  is deferred so the handler will be given access to the 3D API at the correct point in the
+     *  drawing stream as the GPU backend flushes. Since the drawable may mutate, each time it is
+     *  drawn to a GPU-backed canvas a new handler is snapped, representing the drawable's state at
+     *  the time of the snap.
+     *
+     *  When the GPU backend flushes to the 3D API it will call the draw method on the
+     *  GpuDrawHandler. At this time the drawable may add commands to the stream of GPU commands for
+     *  the unerlying 3D API. The draw function takes a GrBackendDrawableInfo which contains
+     *  information about the current state of 3D API which the caller must respect. See
+     *  GrBackendDrawableInfo for more specific details on what information is sent and the
+     *  requirements for different 3D APIs.
+     *
+     *  Additionaly there may be a slight delay from when the drawable adds its commands to when
+     *  those commands are actually submitted to the GPU. Thus the drawable or GpuDrawHandler is
+     *  required to keep any resources that are used by its added commands alive and valid until
+     *  those commands are submitted to the GPU. The GpuDrawHandler will be kept alive and then
+     *  deleted once the commands are submitted to the GPU. The dtor of the GpuDrawHandler is the
+     *  signal to the drawable that the commands have all been submitted. Different 3D APIs may have
+     *  additional requirements for certain resources which require waiting for the GPU to finish
+     *  all work on those resources before reusing or deleting them. In this case, the drawable can
+     *  use the dtor call of the GpuDrawHandler to add a fence to the GPU to track when the GPU work
+     *  has completed.
+     *
+     *  Currently this is only supported for the GPU Vulkan backend.
+     */
+
+    class GpuDrawHandler {
+    public:
+        virtual ~GpuDrawHandler() {}
+
+        virtual void draw(const GrBackendDrawableInfo&) {}
+    };
+
+    /**
+     * Snaps off a GpuDrawHandler to represent the state of the SkDrawable at the time the snap is
+     * called. This is used for executing GPU backend specific draws intermixed with normal Skia GPU
+     * draws. The GPU API, which will be used for the draw, as well as the full matrix, device clip
+     * bounds and imageInfo of the target buffer are passed in as inputs.
+     */
+    std::unique_ptr<GpuDrawHandler> snapGpuDrawHandler(GrBackendApi backendApi,
+                                                       const SkMatrix& matrix,
+                                                       const SkIRect& clipBounds,
+                                                       const SkImageInfo& bufferInfo) {
+        return this->onSnapGpuDrawHandler(backendApi, matrix, clipBounds, bufferInfo);
+    }
+
+    SkPicture* newPictureSnapshot();
+
+    /**
+     *  Return a unique value for this instance. If two calls to this return the same value,
+     *  it is presumed that calling the draw() method will render the same thing as well.
+     *
+     *  Subclasses that change their state should call notifyDrawingChanged() to ensure that
+     *  a new value will be returned the next time it is called.
+     */
+    uint32_t getGenerationID();
+
+    /**
+     *  Return the (conservative) bounds of what the drawable will draw. If the drawable can
+     *  change what it draws (e.g. animation or in response to some external change), then this
+     *  must return a bounds that is always valid for all possible states.
+     */
+    SkRect getBounds();
+
+    /**
+     *  Return approximately how many bytes would be freed if this drawable is destroyed.
+     *  The base implementation returns 0 to indicate that this is unknown.
+     */
+    size_t approximateBytesUsed();
+
+    /**
+     *  Calling this invalidates the previous generation ID, and causes a new one to be computed
+     *  the next time getGenerationID() is called. Typically this is called by the object itself,
+     *  in response to its internal state changing.
+     */
+    void notifyDrawingChanged();
+
+    static SkFlattenable::Type GetFlattenableType() {
+        return kSkDrawable_Type;
+    }
+
+    SkFlattenable::Type getFlattenableType() const override {
+        return kSkDrawable_Type;
+    }
+
+    static sk_sp<SkDrawable> Deserialize(const void* data, size_t size,
+                                          const SkDeserialProcs* procs = nullptr) {
+        return sk_sp<SkDrawable>(static_cast<SkDrawable*>(
+                                  SkFlattenable::Deserialize(
+                                  kSkDrawable_Type, data, size, procs).release()));
+    }
+
+    Factory getFactory() const override { return nullptr; }
+    const char* getTypeName() const override { return nullptr; }
+
+protected:
+    SkDrawable();
+
+    virtual SkRect onGetBounds() = 0;
+    virtual size_t onApproximateBytesUsed();
+    virtual void onDraw(SkCanvas*) = 0;
+
+    virtual std::unique_ptr<GpuDrawHandler> onSnapGpuDrawHandler(GrBackendApi, const SkMatrix&,
+                                                                 const SkIRect& /*clipBounds*/,
+                                                                 const SkImageInfo&) {
+        return nullptr;
+    }
+
+    // TODO: Delete this once Android gets updated to take the clipBounds version above.
+    virtual std::unique_ptr<GpuDrawHandler> onSnapGpuDrawHandler(GrBackendApi, const SkMatrix&) {
+        return nullptr;
+    }
+
+    /**
+     *  Default implementation calls onDraw() with a canvas that records into a picture. Subclasses
+     *  may override if they have a more efficient way to return a picture for the current state
+     *  of their drawable. Note: this picture must draw the same as what would be drawn from
+     *  onDraw().
+     */
+    virtual SkPicture* onNewPictureSnapshot();
+
+private:
+    int32_t fGenerationID;
+};
+
+#endif

package/cpp/skia/include/core/SkEncodedImageFormat.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncodedImageFormat_DEFINED
+#define SkEncodedImageFormat_DEFINED
+
+#include <stdint.h>
+
+/**
+ *  Enum describing format of encoded data.
+ */
+enum class SkEncodedImageFormat {
+#ifdef SK_BUILD_FOR_GOOGLE3
+    kUnknown,
+#endif
+    kBMP,
+    kGIF,
+    kICO,
+    kJPEG,
+    kPNG,
+    kWBMP,
+    kWEBP,
+    kPKM,
+    kKTX,
+    kASTC,
+    kDNG,
+    kHEIF,
+    kAVIF,
+    kJPEGXL,
+};
+
+#endif  // SkEncodedImageFormat_DEFINED

package/cpp/skia/include/core/SkExecutor.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkExecutor_DEFINED
+#define SkExecutor_DEFINED
+
+#include <functional>
+#include <memory>
+#include "include/core/SkTypes.h"
+
+class SK_API SkExecutor {
+public:
+    virtual ~SkExecutor();
+
+    // Create a thread pool SkExecutor with a fixed thread count, by default the number of cores.
+    static std::unique_ptr<SkExecutor> MakeFIFOThreadPool(int threads = 0,
+                                                          bool allowBorrowing = true);
+    static std::unique_ptr<SkExecutor> MakeLIFOThreadPool(int threads = 0,
+                                                          bool allowBorrowing = true);
+
+    // There is always a default SkExecutor available by calling SkExecutor::GetDefault().
+    static SkExecutor& GetDefault();
+    static void SetDefault(SkExecutor*);  // Does not take ownership.  Not thread safe.
+
+    // Add work to execute.
+    virtual void add(std::function<void(void)>) = 0;
+
+    // If it makes sense for this executor, use this thread to execute work for a little while.
+    virtual void borrow() {}
+
+protected:
+    SkExecutor() = default;
+    SkExecutor(const SkExecutor&) = delete;
+    SkExecutor& operator=(const SkExecutor&) = delete;
+};
+
+#endif//SkExecutor_DEFINED

package/cpp/skia/include/core/SkFlattenable.h

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2006 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 SkFlattenable_DEFINED
+#define SkFlattenable_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkReadBuffer;
+class SkWriteBuffer;
+
+struct SkSerialProcs;
+struct SkDeserialProcs;
+
+/** \class SkFlattenable
+
+ SkFlattenable is the base class for objects that need to be flattened
+ into a data stream for either transport or as part of the key to the
+ font cache.
+ */
+class SK_API SkFlattenable : public SkRefCnt {
+public:
+    enum Type {
+        kSkColorFilter_Type,
+        kSkBlender_Type,
+        kSkDrawable_Type,
+        kSkDrawLooper_Type,  // no longer used internally by Skia
+        kSkImageFilter_Type,
+        kSkMaskFilter_Type,
+        kSkPathEffect_Type,
+        kSkShader_Type,
+    };
+
+    typedef sk_sp<SkFlattenable> (*Factory)(SkReadBuffer&);
+
+    SkFlattenable() {}
+
+    /** Implement this to return a factory function pointer that can be called
+     to recreate your class given a buffer (previously written to by your
+     override of flatten().
+     */
+    virtual Factory getFactory() const = 0;
+
+    /**
+     *  Returns the name of the object's class.
+     */
+    virtual const char* getTypeName() const = 0;
+
+    static Factory NameToFactory(const char name[]);
+    static const char* FactoryToName(Factory);
+
+    static void Register(const char name[], Factory);
+
+    /**
+     *  Override this if your subclass needs to record data that it will need to recreate itself
+     *  from its CreateProc (returned by getFactory()).
+     *
+     *  DEPRECATED public : will move to protected ... use serialize() instead
+     */
+    virtual void flatten(SkWriteBuffer&) const {}
+
+    virtual Type getFlattenableType() const = 0;
+
+    //
+    // public ways to serialize / deserialize
+    //
+    sk_sp<SkData> serialize(const SkSerialProcs* = nullptr) const;
+    size_t serialize(void* memory, size_t memory_size,
+                     const SkSerialProcs* = nullptr) const;
+    static sk_sp<SkFlattenable> Deserialize(Type, const void* data, size_t length,
+                                            const SkDeserialProcs* procs = nullptr);
+
+protected:
+    class PrivateInitializer {
+    public:
+        static void InitEffects();
+        static void InitImageFilters();
+    };
+
+private:
+    static void RegisterFlattenablesIfNeeded();
+    static void Finalize();
+
+    friend class SkGraphics;
+
+    using INHERITED = SkRefCnt;
+};
+
+#if defined(SK_DISABLE_EFFECT_DESERIALIZATION)
+    #define SK_REGISTER_FLATTENABLE(type) do{}while(false)
+
+    #define SK_FLATTENABLE_HOOKS(type)                                   \
+        static sk_sp<SkFlattenable> CreateProc(SkReadBuffer&);           \
+        friend class SkFlattenable::PrivateInitializer;                  \
+        Factory getFactory() const override { return nullptr; }          \
+        const char* getTypeName() const override { return #type; }
+#else
+    #define SK_REGISTER_FLATTENABLE(type)                                \
+        SkFlattenable::Register(#type, type::CreateProc)
+
+    #define SK_FLATTENABLE_HOOKS(type)                                   \
+        static sk_sp<SkFlattenable> CreateProc(SkReadBuffer&);           \
+        friend class SkFlattenable::PrivateInitializer;                  \
+        Factory getFactory() const override { return type::CreateProc; } \
+        const char* getTypeName() const override { return #type; }
+#endif
+
+#endif