@shopify/react-native-skia 0.1.115

package/cpp/skia/include/utils/SkRandom.h

@@ -0,0 +1,169 @@
+/*
+ * 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 SkRandom_DEFINED
+#define SkRandom_DEFINED
+
+#include "include/core/SkScalar.h"
+#include "include/private/SkFixed.h"
+#include "include/private/SkFloatBits.h"
+
+/** \class SkRandom
+
+ Utility class that implements pseudo random 32bit numbers using Marsaglia's
+ multiply-with-carry "mother of all" algorithm. Unlike rand(), this class holds
+ its own state, so that multiple instances can be used with no side-effects.
+
+ Has a large period and all bits are well-randomized.
+ */
+class SkRandom {
+public:
+    SkRandom() { init(0); }
+    SkRandom(uint32_t seed) { init(seed); }
+    SkRandom(const SkRandom& rand) : fK(rand.fK), fJ(rand.fJ) {}
+
+    SkRandom& operator=(const SkRandom& rand) {
+        fK = rand.fK;
+        fJ = rand.fJ;
+
+        return *this;
+    }
+
+    /** Return the next pseudo random number as an unsigned 32bit value.
+     */
+    uint32_t nextU() {
+        fK = kKMul*(fK & 0xffff) + (fK >> 16);
+        fJ = kJMul*(fJ & 0xffff) + (fJ >> 16);
+        return (((fK << 16) | (fK >> 16)) + fJ);
+    }
+
+    /** Return the next pseudo random number as a signed 32bit value.
+     */
+    int32_t nextS() { return (int32_t)this->nextU(); }
+
+    /**
+     *  Returns value [0...1) as an IEEE float
+     */
+    float nextF() {
+        int floatint = 0x3f800000 | (int)(this->nextU() >> 9);
+        float f = SkBits2Float(floatint) - 1.0f;
+        return f;
+    }
+
+    /**
+     *  Returns value [min...max) as a float
+     */
+    float nextRangeF(float min, float max) {
+        return min + this->nextF() * (max - min);
+    }
+
+    /** Return the next pseudo random number, as an unsigned value of
+     at most bitCount bits.
+     @param bitCount The maximum number of bits to be returned
+     */
+    uint32_t nextBits(unsigned bitCount) {
+        SkASSERT(bitCount > 0 && bitCount <= 32);
+        return this->nextU() >> (32 - bitCount);
+    }
+
+    /** Return the next pseudo random unsigned number, mapped to lie within
+     [min, max] inclusive.
+     */
+    uint32_t nextRangeU(uint32_t min, uint32_t max) {
+        SkASSERT(min <= max);
+        uint32_t range = max - min + 1;
+        if (0 == range) {
+            return this->nextU();
+        } else {
+            return min + this->nextU() % range;
+        }
+    }
+
+    /** Return the next pseudo random unsigned number, mapped to lie within
+     [0, count).
+     */
+    uint32_t nextULessThan(uint32_t count) {
+        SkASSERT(count > 0);
+        return this->nextRangeU(0, count - 1);
+    }
+
+    /** Return the next pseudo random number expressed as a SkScalar
+     in the range [0..SK_Scalar1).
+     */
+    SkScalar nextUScalar1() { return SkFixedToScalar(this->nextUFixed1()); }
+
+    /** Return the next pseudo random number expressed as a SkScalar
+     in the range [min..max).
+     */
+    SkScalar nextRangeScalar(SkScalar min, SkScalar max) {
+        return this->nextUScalar1() * (max - min) + min;
+    }
+
+    /** Return the next pseudo random number expressed as a SkScalar
+     in the range [-SK_Scalar1..SK_Scalar1).
+     */
+    SkScalar nextSScalar1() { return SkFixedToScalar(this->nextSFixed1()); }
+
+    /** Return the next pseudo random number as a bool.
+     */
+    bool nextBool() { return this->nextU() >= 0x80000000; }
+
+    /** A biased version of nextBool().
+     */
+    bool nextBiasedBool(SkScalar fractionTrue) {
+        SkASSERT(fractionTrue >= 0 && fractionTrue <= SK_Scalar1);
+        return this->nextUScalar1() <= fractionTrue;
+    }
+
+    /** Reset the random object.
+     */
+    void setSeed(uint32_t seed) { init(seed); }
+
+private:
+    // Initialize state variables with LCG.
+    // We must ensure that both J and K are non-zero, otherwise the
+    // multiply-with-carry step will forevermore return zero.
+    void init(uint32_t seed) {
+        fK = NextLCG(seed);
+        if (0 == fK) {
+            fK = NextLCG(fK);
+        }
+        fJ = NextLCG(fK);
+        if (0 == fJ) {
+            fJ = NextLCG(fJ);
+        }
+        SkASSERT(0 != fK && 0 != fJ);
+    }
+    static uint32_t NextLCG(uint32_t seed) { return kMul*seed + kAdd; }
+
+    /** Return the next pseudo random number expressed as an unsigned SkFixed
+     in the range [0..SK_Fixed1).
+     */
+    SkFixed nextUFixed1() { return this->nextU() >> 16; }
+
+    /** Return the next pseudo random number expressed as a signed SkFixed
+     in the range [-SK_Fixed1..SK_Fixed1).
+     */
+    SkFixed nextSFixed1() { return this->nextS() >> 15; }
+
+    //  See "Numerical Recipes in C", 1992 page 284 for these constants
+    //  For the LCG that sets the initial state from a seed
+    enum {
+        kMul = 1664525,
+        kAdd = 1013904223
+    };
+    // Constants for the multiply-with-carry steps
+    enum {
+        kKMul = 30345,
+        kJMul = 18000,
+    };
+
+    uint32_t fK;
+    uint32_t fJ;
+};
+
+#endif

package/cpp/skia/include/utils/SkShadowUtils.h

@@ -0,0 +1,85 @@
+
+/*
+ * 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 SkShadowUtils_DEFINED
+#define SkShadowUtils_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint3.h"
+#include "include/core/SkScalar.h"
+#include "include/private/SkShadowFlags.h"
+
+class SkCanvas;
+class SkMatrix;
+class SkPath;
+class SkResourceCache;
+
+class SK_API SkShadowUtils {
+public:
+    /**
+     * Draw an offset spot shadow and outlining ambient shadow for the given path using a disc
+     * light. The shadow may be cached, depending on the path type and canvas matrix. If the
+     * matrix is perspective or the path is volatile, it will not be cached.
+     *
+     * @param canvas  The canvas on which to draw the shadows.
+     * @param path  The occluder used to generate the shadows.
+     * @param zPlaneParams  Values for the plane function which returns the Z offset of the
+     *  occluder from the canvas based on local x and y values (the current matrix is not applied).
+     * @param lightPos  Generally, the 3D position of the light relative to the canvas plane.
+     *                  If kDirectionalLight_ShadowFlag is set, this specifies a vector pointing
+     *                  towards the light.
+     * @param lightRadius  Generally, the radius of the disc light.
+     *                     If DirectionalLight_ShadowFlag is set, this specifies the amount of
+     *                     blur when the occluder is at Z offset == 1. The blur will grow linearly
+     *                     as the Z value increases.
+     * @param ambientColor  The color of the ambient shadow.
+     * @param spotColor  The color of the spot shadow.
+     * @param flags  Options controlling opaque occluder optimizations, shadow appearance,
+     *               and light position. See SkShadowFlags.
+     */
+    static void DrawShadow(SkCanvas* canvas, const SkPath& path, const SkPoint3& zPlaneParams,
+                           const SkPoint3& lightPos, SkScalar lightRadius,
+                           SkColor ambientColor, SkColor spotColor,
+                           uint32_t flags = SkShadowFlags::kNone_ShadowFlag);
+
+    /**
+     * Generate bounding box for shadows relative to path. Includes both the ambient and spot
+     * shadow bounds.
+     *
+     * @param ctm  Current transformation matrix to device space.
+     * @param path  The occluder used to generate the shadows.
+     * @param zPlaneParams  Values for the plane function which returns the Z offset of the
+     *  occluder from the canvas based on local x and y values (the current matrix is not applied).
+     * @param lightPos  Generally, the 3D position of the light relative to the canvas plane.
+     *                  If kDirectionalLight_ShadowFlag is set, this specifies a vector pointing
+     *                  towards the light.
+     * @param lightRadius  Generally, the radius of the disc light.
+     *                     If DirectionalLight_ShadowFlag is set, this specifies the amount of
+     *                     blur when the occluder is at Z offset == 1. The blur will grow linearly
+     *                     as the Z value increases.
+     * @param flags  Options controlling opaque occluder optimizations, shadow appearance,
+     *               and light position. See SkShadowFlags.
+     * @param bounds Return value for shadow bounding box.
+     * @return Returns true if successful, false otherwise.
+     */
+    static bool GetLocalBounds(const SkMatrix& ctm, const SkPath& path,
+                               const SkPoint3& zPlaneParams, const SkPoint3& lightPos,
+                               SkScalar lightRadius, uint32_t flags, SkRect* bounds);
+
+    /**
+     * Helper routine to compute color values for one-pass tonal alpha.
+     *
+     * @param inAmbientColor  Original ambient color
+     * @param inSpotColor  Original spot color
+     * @param outAmbientColor  Modified ambient color
+     * @param outSpotColor  Modified spot color
+     */
+    static void ComputeTonalColors(SkColor inAmbientColor, SkColor inSpotColor,
+                                   SkColor* outAmbientColor, SkColor* outSpotColor);
+};
+
+#endif

package/cpp/skia/include/utils/SkTextUtils.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTextUtils_DEFINED
+#define SkTextUtils_DEFINED
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkString.h"
+
+class SkPath;
+
+class SK_API SkTextUtils {
+public:
+    enum Align {
+        kLeft_Align,
+        kCenter_Align,
+        kRight_Align,
+    };
+
+    static void Draw(SkCanvas*, const void* text, size_t size, SkTextEncoding,
+                     SkScalar x, SkScalar y, const SkFont&, const SkPaint&, Align = kLeft_Align);
+
+    static void DrawString(SkCanvas* canvas, const char text[], SkScalar x, SkScalar y,
+                           const SkFont& font, const SkPaint& paint, Align align = kLeft_Align) {
+        Draw(canvas, text, strlen(text), SkTextEncoding::kUTF8, x, y, font, paint, align);
+    }
+
+    static void GetPath(const void* text, size_t length, SkTextEncoding, SkScalar x, SkScalar y,
+                        const SkFont&, SkPath*);
+};
+
+#endif

package/cpp/skia/include/utils/SkTraceEventPhase.h

@@ -0,0 +1,19 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef SkTraceEventPhase_DEFINED
+#define SkTraceEventPhase_DEFINED
+
+// Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
+#define TRACE_EVENT_PHASE_BEGIN ('B')
+#define TRACE_EVENT_PHASE_END ('E')
+#define TRACE_EVENT_PHASE_COMPLETE ('X')
+#define TRACE_EVENT_PHASE_INSTANT ('I')
+#define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
+#define TRACE_EVENT_PHASE_ASYNC_END ('F')
+#define TRACE_EVENT_PHASE_COUNTER ('C')
+#define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
+#define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
+#define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
+
+#endif  // SkTraceEventPhase_DEFINED

package/cpp/skia/include/utils/mac/SkCGUtils.h

@@ -0,0 +1,78 @@
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkCGUtils_DEFINED
+#define SkCGUtils_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkSize.h"
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+
+#ifdef SK_BUILD_FOR_MAC
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+#ifdef SK_BUILD_FOR_IOS
+#include <CoreGraphics/CoreGraphics.h>
+#endif
+
+class SkBitmap;
+class SkData;
+class SkPixmap;
+class SkStreamRewindable;
+
+SK_API CGContextRef SkCreateCGContext(const SkPixmap&);
+
+/**
+ *  Given a CGImage, allocate an SkBitmap and copy the image's pixels into it. If scaleToFit is not
+ *  null, use it to determine the size of the bitmap, and scale the image to fill the bitmap.
+ *  Otherwise use the image's width/height.
+ *
+ *  On failure, return false, and leave bitmap unchanged.
+ */
+SK_API bool SkCreateBitmapFromCGImage(SkBitmap* dst, CGImageRef src);
+
+SK_API sk_sp<SkImage> SkMakeImageFromCGImage(CGImageRef);
+
+/**
+ *  Copy the pixels from src into the memory specified by info/rowBytes/dstPixels. On failure,
+ *  return false (e.g. ImageInfo incompatible with src).
+ */
+SK_API bool SkCopyPixelsFromCGImage(const SkImageInfo& info, size_t rowBytes, void* dstPixels,
+                                    CGImageRef src);
+static inline bool SkCopyPixelsFromCGImage(const SkPixmap& dst, CGImageRef src) {
+    return SkCopyPixelsFromCGImage(dst.info(), dst.rowBytes(), dst.writable_addr(), src);
+}
+
+/**
+ *  Create an imageref from the specified bitmap using the specified colorspace.
+ *  If space is NULL, then CGColorSpaceCreateDeviceRGB() is used.
+ */
+SK_API CGImageRef SkCreateCGImageRefWithColorspace(const SkBitmap& bm,
+                                                   CGColorSpaceRef space);
+
+/**
+ *  Create an imageref from the specified bitmap using the colorspace returned
+ *  by CGColorSpaceCreateDeviceRGB()
+ */
+static inline CGImageRef SkCreateCGImageRef(const SkBitmap& bm) {
+    return SkCreateCGImageRefWithColorspace(bm, nil);
+}
+
+/**
+ *  Draw the bitmap into the specified CG context. The bitmap will be converted
+ *  to a CGImage using the generic RGB colorspace. (x,y) specifies the position
+ *  of the top-left corner of the bitmap. The bitmap is converted using the
+ *  colorspace returned by CGColorSpaceCreateDeviceRGB()
+ */
+void SkCGDrawBitmap(CGContextRef, const SkBitmap&, float x, float y);
+
+#endif  // defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+#endif  // SkCGUtils_DEFINED

package/cpp/skia/modules/skresources/include/SkResources.h

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkResources_DEFINED
+#define SkResources_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkMatrix.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTypeface.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkMutex.h"
+#include "include/private/SkTHash.h"
+
+#include <memory>
+
+class SkAnimCodecPlayer;
+class SkImage;
+
+namespace skresources {
+
+/**
+ * Image asset proxy interface.
+ */
+class SK_API ImageAsset : public SkRefCnt {
+public:
+    /**
+     * Returns true if the image asset is animated.
+     */
+    virtual bool isMultiFrame() = 0;
+
+    /**
+     * DEPRECATED: override getFrameData() instead.
+     *
+     * Returns the SkImage for a given frame.
+     *
+     * If the image asset is static, getFrame() is only called once, at animation load time.
+     * Otherwise, this gets invoked every time the animation time is adjusted (on every seek).
+     *
+     * Embedders should cache and serve the same SkImage whenever possible, for efficiency.
+     *
+     * @param t   Frame time code, in seconds, relative to the image layer timeline origin
+     *            (in-point).
+     */
+    virtual sk_sp<SkImage> getFrame(float t);
+
+    struct FrameData {
+        // SkImage payload.
+        sk_sp<SkImage>    image;
+        // Resampling parameters.
+        SkSamplingOptions sampling;
+        // Additional image transform to be applied before AE scaling rules.
+        SkMatrix          matrix = SkMatrix::I();
+    };
+
+    /**
+     * Returns the payload for a given frame.
+     *
+     * If the image asset is static, getFrameData() is only called once, at animation load time.
+     * Otherwise, this gets invoked every time the animation time is adjusted (on every seek).
+     *
+     * Embedders should cache and serve the same SkImage whenever possible, for efficiency.
+     *
+     * @param t   Frame time code, in seconds, relative to the image layer timeline origin
+     *            (in-point).
+     */
+    virtual FrameData getFrameData(float t);
+};
+
+class MultiFrameImageAsset final : public ImageAsset {
+public:
+    /**
+    * By default, images are decoded on-the-fly, at rasterization time.
+    * Large images may cause jank as decoding is expensive (and can thrash internal caches).
+    *
+    * Pass |predecode| true to force-decode all images upfront, at the cost of potentially more RAM
+    * and slower animation build times.
+    */
+    static sk_sp<MultiFrameImageAsset> Make(sk_sp<SkData>, bool predecode = false);
+
+    bool isMultiFrame() override;
+
+    sk_sp<SkImage> getFrame(float t) override;
+
+private:
+    explicit MultiFrameImageAsset(std::unique_ptr<SkAnimCodecPlayer>, bool predecode);
+
+    sk_sp<SkImage> generateFrame(float t);
+
+    std::unique_ptr<SkAnimCodecPlayer> fPlayer;
+    sk_sp<SkImage>                     fCachedFrame;
+    bool                               fPreDecode;
+
+    using INHERITED = ImageAsset;
+};
+
+/**
+ * External track (e.g. audio playback) interface.
+ *
+ * Used to wrap data payload and playback controllers.
+ */
+class ExternalTrackAsset : public SkRefCnt {
+public:
+    /**
+     * Playback control callback, emitted for each corresponding Animation::seek().
+     *
+     * @param t  Frame time code, in seconds, relative to the layer's timeline origin
+     *           (in-point).
+     *
+     * Negative |t| values are used to signal off state (stop playback outside layer span).
+     */
+    virtual void seek(float t) = 0;
+};
+
+/**
+ * ResourceProvider is an interface that lets rich-content modules defer loading of external
+ * resources (images, fonts, etc.) to embedding clients.
+ */
+class SK_API ResourceProvider : public SkRefCnt {
+public:
+    /**
+     * Load a generic resource (currently only nested animations) specified by |path| + |name|,
+     * and return as an SkData.
+     */
+    virtual sk_sp<SkData> load(const char[] /* resource_path */,
+                               const char[] /* resource_name */) const {
+        return nullptr;
+    }
+
+    /**
+     * Load an image asset specified by |path| + |name|, and returns the corresponding
+     * ImageAsset proxy.
+     */
+    virtual sk_sp<ImageAsset> loadImageAsset(const char[] /* resource_path */,
+                                             const char[] /* resource_name */,
+                                             const char[] /* resource_id   */) const {
+        return nullptr;
+    }
+
+    /**
+     * Load an external audio track specified by |path|/|name|/|id|.
+     */
+    virtual sk_sp<ExternalTrackAsset> loadAudioAsset(const char[] /* resource_path */,
+                                                     const char[] /* resource_name */,
+                                                     const char[] /* resource_id   */) {
+        return nullptr;
+    }
+
+    /**
+     * DEPRECATED: implement loadTypeface() instead.
+     *
+     * Load an external font and return as SkData.
+     *
+     * @param name  font name    ("fName" Lottie property)
+     * @param url   web font URL ("fPath" Lottie property)
+     *
+     * -- Note --
+     *
+     *   This mechanism assumes monolithic fonts (single data blob).  Some web font providers may
+     *   serve multiple font blobs, segmented for various unicode ranges, depending on user agent
+     *   capabilities (woff, woff2).  In that case, the embedder would need to advertise no user
+     *   agent capabilities when fetching the URL, in order to receive full font data.
+     */
+    virtual sk_sp<SkData> loadFont(const char[] /* name */,
+                                   const char[] /* url  */) const {
+        return nullptr;
+    }
+
+    /**
+     * Load an external font and return as SkTypeface.
+     *
+     * @param name  font name
+     * @param url   web font URL
+     */
+    virtual sk_sp<SkTypeface> loadTypeface(const char[] /* name */,
+                                           const char[] /* url  */) const {
+        return nullptr;
+    }
+};
+
+class FileResourceProvider final : public ResourceProvider {
+public:
+    static sk_sp<FileResourceProvider> Make(SkString base_dir, bool predecode = false);
+
+    sk_sp<SkData> load(const char resource_path[], const char resource_name[]) const override;
+
+    sk_sp<ImageAsset> loadImageAsset(const char[], const char[], const char[]) const override;
+
+private:
+    FileResourceProvider(SkString, bool);
+
+    const SkString fDir;
+    const bool     fPredecode;
+
+    using INHERITED = ResourceProvider;
+};
+
+class ResourceProviderProxyBase : public ResourceProvider {
+protected:
+    explicit ResourceProviderProxyBase(sk_sp<ResourceProvider>);
+
+    sk_sp<SkData> load(const char[], const char[]) const override;
+    sk_sp<ImageAsset> loadImageAsset(const char[], const char[], const char[]) const override;
+    sk_sp<SkTypeface> loadTypeface(const char[], const char[]) const override;
+    sk_sp<SkData> loadFont(const char[], const char[]) const override;
+    sk_sp<ExternalTrackAsset> loadAudioAsset(const char[], const char[], const char[]) override;
+
+private:
+    const sk_sp<ResourceProvider> fProxy;
+};
+
+class SK_API CachingResourceProvider final : public ResourceProviderProxyBase {
+public:
+    static sk_sp<CachingResourceProvider> Make(sk_sp<ResourceProvider> rp) {
+        return rp ? sk_sp<CachingResourceProvider>(new CachingResourceProvider(std::move(rp)))
+                  : nullptr;
+    }
+
+private:
+    explicit CachingResourceProvider(sk_sp<ResourceProvider>);
+
+    sk_sp<ImageAsset> loadImageAsset(const char[], const char[], const char[]) const override;
+
+    mutable SkMutex                                 fMutex;
+    mutable SkTHashMap<SkString, sk_sp<ImageAsset>> fImageCache;
+
+    using INHERITED = ResourceProviderProxyBase;
+};
+
+class DataURIResourceProviderProxy final : public ResourceProviderProxyBase {
+public:
+    static sk_sp<DataURIResourceProviderProxy> Make(sk_sp<ResourceProvider> rp,
+                                                    bool predecode = false);
+
+private:
+    DataURIResourceProviderProxy(sk_sp<ResourceProvider>, bool);
+
+    sk_sp<ImageAsset> loadImageAsset(const char[], const char[], const char[]) const override;
+    sk_sp<SkTypeface> loadTypeface(const char[], const char[]) const override;
+
+    const bool fPredecode;
+
+    using INHERITED = ResourceProviderProxyBase;
+};
+
+} // namespace skresources
+
+#endif // SkResources_DEFINED