@shopify/react-native-skia 0.1.128 → 0.1.131

package/cpp/api/JsiSkTypefaceFactory.h

@@ -17,8 +17,12 @@ namespace RNSkia {
     public:
         JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
             auto data = JsiSkData::fromValue(runtime, arguments[0]);
+            auto typeface = SkFontMgr::RefDefault()->makeFromData(std::move(data));
+            if(typeface == nullptr) {
+              return jsi::Value::null();
+            }
             return jsi::Object::createFromHostObject(
-                runtime, std::make_shared<JsiSkTypeface>(getContext(), SkFontMgr::RefDefault()->makeFromData(std::move(data))));
+                runtime, std::make_shared<JsiSkTypeface>(getContext(), typeface));
         }
 
         JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkTypefaceFactory, MakeFreeTypeFaceFromData))

package/cpp/api/JsiSkVertices.h

@@ -4,8 +4,6 @@
 #include <utility>
 #include <jsi/jsi.h>
 
-#include <jsi/jsi.h>
-
 #include "JsiSkHostObjects.h"
 
 #pragma clang diagnostic push

package/cpp/rnskia/RNSkInfoParameter.h

@@ -23,6 +23,7 @@ using RNSkTouchPoint = struct {
   double y;
   double force;
   RNSkTouchType type;
+  size_t id;
   long timestamp;
 };
 
@@ -45,6 +46,7 @@ public:
         touchObj.setProperty(runtime, "force", t.force);
         touchObj.setProperty(runtime, "type", (double)t.type);
         touchObj.setProperty(runtime, "timestamp", (double)t.timestamp / 1000.0);
+        touchObj.setProperty(runtime, "id", (double)t.id);
         touches.setValueAtIndex(runtime, n, touchObj);
       }
       ops.setValueAtIndex(runtime, i, touches);

package/cpp/rnskia/values/RNSkValue.h

@@ -43,7 +43,7 @@ public:
     unsubscribe();
     
     // Verify input
-    if(value.isObject() && value.asObject(runtime).isHostObject(runtime)) {
+    if(value.isObject() && value.asObject(runtime).isHostObject<RNSkAnimation>(runtime)) {
       auto animation = value.asObject(runtime).getHostObject<RNSkAnimation>(runtime);
       if(animation != nullptr) {
         // Now we have a value animation - let us connect and start

package/cpp/skia/include/codec/SkCodec.h

@@ -758,6 +758,12 @@ protected:
             std::unique_ptr<SkStream>,
             SkEncodedOrigin = kTopLeft_SkEncodedOrigin);
 
+    void setSrcXformFormat(XformFormat pixelFormat);
+
+    XformFormat getSrcXformFormat() const {
+        return fSrcXformFormat;
+    }
+
     virtual SkISize onGetScaledDimensions(float /*desiredScale*/) const {
         // By default, scaling is not supported.
         return this->dimensions();
@@ -876,7 +882,7 @@ protected:
 
 private:
     const SkEncodedInfo                fEncodedInfo;
-    const XformFormat                  fSrcXformFormat;
+    XformFormat                        fSrcXformFormat;
     std::unique_ptr<SkStream>          fStream;
     bool                               fNeedsRewind;
     const SkEncodedOrigin              fOrigin;

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAlphaType_DEFINED
+#define SkAlphaType_DEFINED
+
+/** \enum SkAlphaType
+    Describes how to interpret the alpha component of a pixel. A pixel may
+    be opaque, or alpha, describing multiple levels of transparency.
+
+    In simple blending, alpha weights the draw color and the destination
+    color to create a new color. If alpha describes a weight from zero to one:
+
+    new color = draw color * alpha + destination color * (1 - alpha)
+
+    In practice alpha is encoded in two or more bits, where 1.0 equals all bits set.
+
+    RGB may have alpha included in each component value; the stored
+    value is the original RGB multiplied by alpha. Premultiplied color
+    components improve performance.
+*/
+enum SkAlphaType : int {
+    kUnknown_SkAlphaType,                          //!< uninitialized
+    kOpaque_SkAlphaType,                           //!< pixel is opaque
+    kPremul_SkAlphaType,                           //!< pixel components are premultiplied by alpha
+    kUnpremul_SkAlphaType,                         //!< pixel components are independent of alpha
+    kLastEnum_SkAlphaType = kUnpremul_SkAlphaType, //!< last valid value
+};
+
+/** Returns true if SkAlphaType equals kOpaque_SkAlphaType.
+
+    kOpaque_SkAlphaType is a hint that the SkColorType is opaque, or that all
+    alpha values are set to their 1.0 equivalent. If SkAlphaType is
+    kOpaque_SkAlphaType, and SkColorType is not opaque, then the result of
+    drawing any pixel with a alpha value less than 1.0 is undefined.
+*/
+static inline bool SkAlphaTypeIsOpaque(SkAlphaType at) {
+    return kOpaque_SkAlphaType == at;
+}
+
+#endif

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

@@ -18,6 +18,7 @@
 #include "include/core/SkTileMode.h"
 
 class SkBitmap;
+class SkColorSpace;
 struct SkMask;
 class SkMipmap;
 struct SkIRect;
@@ -158,7 +159,7 @@ public:
 
         @return  SkColorSpace in SkImageInfo, or nullptr
     */
-    SkColorSpace* colorSpace() const { return fPixmap.colorSpace(); }
+    SkColorSpace* colorSpace() const;
 
     /** Returns smart pointer to SkColorSpace, the range of colors, associated with
         SkImageInfo. The smart pointer tracks the number of objects sharing this
@@ -168,7 +169,7 @@ public:
 
         @return  SkColorSpace in SkImageInfo wrapped in a smart pointer
     */
-    sk_sp<SkColorSpace> refColorSpace() const { return fPixmap.info().refColorSpace(); }
+    sk_sp<SkColorSpace> refColorSpace() const;
 
     /** Returns number of bytes per pixel required by SkColorType.
         Returns zero if colorType( is kUnknown_SkColorType.
@@ -1190,6 +1191,7 @@ private:
 
     friend class SkImage_Raster;
     friend class SkReadBuffer;        // unflatten
+    friend class GrProxyProvider;     // fMips
 };
 
 ///////////////////////////////////////////////////////////////////////////////

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

@@ -31,6 +31,7 @@
 
 #include <cstring>
 #include <memory>
+#include <optional>
 #include <vector>
 
 #ifndef SK_SUPPORT_LEGACY_GETTOTALMATRIX
@@ -58,16 +59,15 @@ class SkPixmap;
 class SkRegion;
 class SkRRect;
 struct SkRSXform;
-struct SkCustomMesh;
+class SkMesh;
 class SkSpecialImage;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 class SkVertices;
 
-namespace skstd {
-    template<typename T> class optional;
-}
+namespace skgpu::graphite { class Recorder; }
+namespace SkRecords { class Draw; }
 
 /** \class SkCanvas
     SkCanvas provides an interface for drawing, and how the drawing is clipped and transformed.
@@ -300,6 +300,12 @@ public:
      */
     virtual GrRecordingContext* recordingContext();
 
+    /** Returns Recorder for the GPU surface associated with SkCanvas.
+
+        @return  Recorder, if available; nullptr otherwise
+     */
+    virtual skgpu::graphite::Recorder* recorder();
+
     /** Sometimes a canvas is owned by a surface. If it is, getSurface() will return a bare
      *  pointer to that surface, else this will return nullptr.
      */
@@ -1438,7 +1444,8 @@ public:
     /** \enum SkCanvas::SrcRectConstraint
         SrcRectConstraint controls the behavior at the edge of source SkRect,
         provided to drawImageRect() when there is any filtering. If kStrict is set,
-        then extra code is used to ensure it nevers samples outside of the src-rect.
+        then extra code is used to ensure it never samples outside of the src-rect.
+        kStrict_SrcRectConstraint disables the use of mipmaps and anisotropic filtering.
     */
     enum SrcRectConstraint {
         kStrict_SrcRectConstraint, //!< sample only inside bounds; slower
@@ -1953,9 +1960,9 @@ public:
     /**
         Experimental, under active development, and subject to change without notice.
 
-        Draws a mesh using a user-defined specification (see SkCustomMeshSpecification).
+        Draws a mesh using a user-defined specification (see SkMeshSpecification).
 
-        SkBlender is ignored if SkCustomMesh's specification does not output fragment shader color.
+        SkBlender is ignored if SkMesh's specification does not output fragment shader color.
         Otherwise, it combines
             - the SkShader if SkPaint contains SkShader
             - or the opaque SkPaint color if SkPaint does not contain SkShader
@@ -1963,13 +1970,13 @@ public:
 
         SkMaskFilter, SkPathEffect, and antialiasing on SkPaint are ignored.
 
-        @param cm        the custom mesh vertices and compatible specification.
+        @param mesh      the mesh vertices and compatible specification.
         @param blender   combines vertices colors with SkShader if present or SkPaint opaque color
                          if not. Ignored if the custom mesh does not output color. Defaults to
                          SkBlendMode::kModulate if nullptr.
         @param paint     specifies the SkShader, used as SkVertices texture, may be nullptr
     */
-    void drawCustomMesh(SkCustomMesh cm, sk_sp<SkBlender> blender, const SkPaint& paint);
+    void drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint);
 #endif
 
     /** Draws a Coons patch: the interpolation of four cubics with shared corners,
@@ -2193,7 +2200,7 @@ protected:
 
 #ifndef SK_ENABLE_EXPERIMENTAL_CUSTOM_MESH
     // Define this in protected so we can still access internally for testing.
-    void drawCustomMesh(SkCustomMesh cm, sk_sp<SkBlender> blender, const SkPaint& paint);
+    void drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint);
 #endif
 
     // NOTE: If you are adding a new onDraw virtual to SkCanvas, PLEASE add an override to
@@ -2237,7 +2244,7 @@ protected:
     virtual void onDrawVerticesObject(const SkVertices* vertices, SkBlendMode mode,
                                       const SkPaint& paint);
 #ifdef SK_ENABLE_SKSL
-    virtual void onDrawCustomMesh(SkCustomMesh, sk_sp<SkBlender>, const SkPaint&);
+    virtual void onDrawMesh(const SkMesh&, sk_sp<SkBlender>, const SkPaint&);
 #endif
     virtual void onDrawAnnotation(const SkRect& rect, const char key[], SkData* value);
     virtual void onDrawShadowRec(const SkPath&, const SkDrawShadowRec&);
@@ -2266,12 +2273,12 @@ protected:
 #if SK_SUPPORT_GPU
     /** Experimental
      */
-    virtual sk_sp<GrSlug> doConvertBlobToSlug(
-            const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
+    virtual sk_sp<GrSlug> onConvertGlyphRunListToSlug(
+            const SkGlyphRunList& glyphRunList, const SkPaint& paint);
 
     /** Experimental
      */
-    virtual void doDrawSlug(GrSlug* slug);
+    virtual void onDrawSlug(const GrSlug* slug);
 #endif
 
 private:
@@ -2293,7 +2300,7 @@ private:
         kYes = true
     };
     // call the appropriate predrawNotify and create a layer if needed.
-    skstd::optional<AutoLayerForImageFilter> aboutToDraw(
+    std::optional<AutoLayerForImageFilter> aboutToDraw(
         SkCanvas* canvas,
         const SkPaint& paint,
         const SkRect* rawBounds = nullptr,
@@ -2355,16 +2362,16 @@ private:
         void reset(SkBaseDevice* device);
     };
 
-    SkDeque     fMCStack;
-    // points to top of stack
-    MCRec*      fMCRec;
-
     // the first N recs that can fit here mean we won't call malloc
     static constexpr int kMCRecSize      = 96; // most recent measurement
     static constexpr int kMCRecCount     = 32; // common depth for save/restores
 
     intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
 
+    SkDeque     fMCStack;
+    // points to top of stack
+    MCRec*      fMCRec;
+
     // Installed via init()
     sk_sp<SkBaseDevice> fBaseDevice;
     const SkSurfaceProps fProps;
@@ -2397,6 +2404,10 @@ private:
     friend class SkPictureRecord;   // predrawNotify (why does it need it? <reed>)
     friend class SkOverdrawCanvas;
     friend class SkRasterHandleAllocator;
+    friend class SkRecords::Draw;
+    template <typename Key>
+    friend class SkTestCanvas;
+
 protected:
     // For use by SkNoDrawCanvas (via SkCanvasVirtualEnforcer, which can't be a friend)
     SkCanvas(const SkIRect& bounds);
@@ -2419,7 +2430,7 @@ private:
     /** Experimental
      * Draw an GrSlug given the current canvas state.
      */
-    void drawSlug(GrSlug* slug);
+    void drawSlug(const GrSlug* slug);
 #endif
 
     /** Experimental

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

@@ -8,7 +8,7 @@
 #ifndef SkColor_DEFINED
 #define SkColor_DEFINED
 
-#include "include/core/SkImageInfo.h"
+#include "include/core/SkAlphaType.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
 

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

@@ -13,6 +13,7 @@
 #include "include/core/SkFlattenable.h"
 
 class SkColorMatrix;
+class SkColorSpace;
 
 /**
 *  ColorFilters are optional objects in the drawing pipeline. When present in

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkColorType_DEFINED
+#define SkColorType_DEFINED
+
+#include "include/core/SkTypes.h"
+
+/** \enum SkColorType
+    Describes how pixel bits encode color. A pixel may be an alpha mask, a grayscale, RGB, or ARGB.
+
+    kN32_SkColorType selects the native 32-bit ARGB format for the current configuration. This can
+    lead to inconsistent results across platforms, so use with caution.
+*/
+enum SkColorType : int {
+    kUnknown_SkColorType,      //!< uninitialized
+    kAlpha_8_SkColorType,      //!< pixel with alpha in 8-bit byte
+    kRGB_565_SkColorType,      //!< pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
+    kARGB_4444_SkColorType,    //!< pixel with 4 bits for alpha, red, green, blue; in 16-bit word
+    kRGBA_8888_SkColorType,    //!< pixel with 8 bits for red, green, blue, alpha; in 32-bit word
+    kRGB_888x_SkColorType,     //!< pixel with 8 bits each for red, green, blue; in 32-bit word
+    kBGRA_8888_SkColorType,    //!< pixel with 8 bits for blue, green, red, alpha; in 32-bit word
+    kRGBA_1010102_SkColorType, //!< 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
+    kBGRA_1010102_SkColorType, //!< 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
+    kRGB_101010x_SkColorType,  //!< pixel with 10 bits each for red, green, blue; in 32-bit word
+    kBGR_101010x_SkColorType,  //!< pixel with 10 bits each for blue, green, red; in 32-bit word
+    kGray_8_SkColorType,       //!< pixel with grayscale level in 8-bit byte
+    kRGBA_F16Norm_SkColorType, //!< pixel with half floats in [0,1] for red, green, blue, alpha;
+                               //   in 64-bit word
+    kRGBA_F16_SkColorType,     //!< pixel with half floats for red, green, blue, alpha;
+                               //   in 64-bit word
+    kRGBA_F32_SkColorType,     //!< pixel using C float for red, green, blue, alpha; in 128-bit word
+
+    // The following 6 colortypes are just for reading from - not for rendering to
+    kR8G8_unorm_SkColorType,         //!< pixel with a uint8_t for red and green
+
+    kA16_float_SkColorType,          //!< pixel with a half float for alpha
+    kR16G16_float_SkColorType,       //!< pixel with a half float for red and green
+
+    kA16_unorm_SkColorType,          //!< pixel with a little endian uint16_t for alpha
+    kR16G16_unorm_SkColorType,       //!< pixel with a little endian uint16_t for red and green
+    kR16G16B16A16_unorm_SkColorType, //!< pixel with a little endian uint16_t for red, green, blue
+                                     //   and alpha
+
+    kSRGBA_8888_SkColorType,
+    kR8_unorm_SkColorType,
+
+    kLastEnum_SkColorType     = kR8_unorm_SkColorType, //!< last valid value
+
+#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
+    kN32_SkColorType          = kBGRA_8888_SkColorType,//!< native 32-bit BGRA encoding
+
+#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
+    kN32_SkColorType          = kRGBA_8888_SkColorType,//!< native 32-bit RGBA encoding
+
+#else
+    #error "SK_*32_SHIFT values must correspond to BGRA or RGBA byte order"
+#endif
+};
+static constexpr int kSkColorTypeCnt = static_cast<int>(kLastEnum_SkColorType) + 1;
+
+#endif

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

@@ -60,7 +60,7 @@ public:
     sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
                                       int width,
                                       int height,
-                                      GrMipmapped mipMapped,
+                                      GrMipmapped mipmapped,
                                       GrSurfaceOrigin origin,
                                       SkColorType colorType,
                                       SkAlphaType alphaType,

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

@@ -103,6 +103,12 @@ public:
      */
     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,
@@ -132,6 +138,7 @@ protected:
     SkDrawable();
 
     virtual SkRect onGetBounds() = 0;
+    virtual size_t onApproximateBytesUsed();
     virtual void onDraw(SkCanvas*) = 0;
 
     virtual std::unique_ptr<GpuDrawHandler> onSnapGpuDrawHandler(GrBackendApi, const SkMatrix&,

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

@@ -30,6 +30,7 @@ enum class SkEncodedImageFormat {
     kDNG,
     kHEIF,
     kAVIF,
+    kJPEGXL,
 };
 
 #endif  // SkEncodedImageFormat_DEFINED

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

@@ -331,7 +331,7 @@ public:
         @param text        character storage encoded with SkTextEncoding
         @param byteLength  length of character storage in bytes
         @param bounds      returns bounding box relative to (0, 0) if not nullptr
-        @return            number of glyphs represented by text of length byteLength
+        @return            the sum of the default advance widths
     */
     SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                          SkRect* bounds = nullptr) const {
@@ -347,7 +347,7 @@ public:
         @param byteLength  length of character storage in bytes
         @param bounds      returns bounding box relative to (0, 0) if not nullptr
         @param paint       optional; may be nullptr
-        @return            number of glyphs represented by text of length byteLength
+        @return            the sum of the default advance widths
     */
     SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                          SkRect* bounds, const SkPaint* paint) const;
@@ -527,8 +527,9 @@ private:
     bool hasSomeAntiAliasing() const;
 
     friend class SkFontPriv;
-    friend class SkGlyphRunListPainter;
+    friend class SkGlyphRunListPainterCPU;
     friend class SkStrikeSpec;
+    friend class SkRemoteGlyphCacheTest;
 };
 
 #endif

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

@@ -8,6 +8,7 @@
 #ifndef SkFontArguments_DEFINED
 #define SkFontArguments_DEFINED
 
+#include "include/core/SkColor.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
 
@@ -22,7 +23,27 @@ struct SkFontArguments {
         int coordinateCount;
     };
 
-    SkFontArguments() : fCollectionIndex(0), fVariationDesignPosition{nullptr, 0} {}
+    /** Specify a palette to use and overrides for palette entries.
+     *
+     *  `overrides` is a list of pairs of palette entry index and color.
+     *  The overriden palette entries will use the associated color.
+     *  Override pairs with palette entry indices out of range will not be applied.
+     *  Later override entries override earlier ones.
+     */
+    struct Palette {
+        struct Override {
+            int index;
+            SkColor color;
+        };
+        int index;
+        const Override* overrides;
+        int overrideCount;
+    };
+
+    SkFontArguments()
+            : fCollectionIndex(0)
+            , fVariationDesignPosition{nullptr, 0}
+            , fPalette{0, nullptr, 0} {}
 
     /** Specify the index of the desired font.
      *
@@ -54,9 +75,20 @@ struct SkFontArguments {
     VariationPosition getVariationDesignPosition() const {
         return fVariationDesignPosition;
     }
+
+    SkFontArguments& setPalette(Palette palette) {
+        fPalette.index = palette.index;
+        fPalette.overrides = palette.overrides;
+        fPalette.overrideCount = palette.overrideCount;
+        return *this;
+    }
+
+    Palette getPalette() const { return fPalette; }
+
 private:
     int fCollectionIndex;
     VariationPosition fVariationDesignPosition;
+    Palette fPalette;
 };
 
 #endif

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

@@ -12,6 +12,7 @@
 
 class SkData;
 class SkImageGenerator;
+class SkOpenTypeSVGDecoder;
 class SkTraceMemoryDump;
 
 class SK_API SkGraphics {
@@ -137,6 +138,18 @@ public:
     static ImageGeneratorFromEncodedDataFactory
                     SetImageGeneratorFromEncodedDataFactory(ImageGeneratorFromEncodedDataFactory);
 
+    /**
+     *  To draw OpenType SVG data, Skia will look at this runtime function pointer. If this function
+     *  pointer is set, the SkTypeface implementations which support OpenType SVG will call this
+     *  function to create an SkOpenTypeSVGDecoder to decode the OpenType SVG and draw it as needed.
+     *  If this function is not set, the SkTypeface implementations will generally not support
+     *  OpenType SVG and attempt to use other glyph representations if available.
+     */
+    using OpenTypeSVGDecoderFactory =
+            std::unique_ptr<SkOpenTypeSVGDecoder> (*)(const uint8_t* svg, size_t length);
+    static OpenTypeSVGDecoderFactory SetOpenTypeSVGDecoderFactory(OpenTypeSVGDecoderFactory);
+    static OpenTypeSVGDecoderFactory GetOpenTypeSVGDecoderFactory();
+
     /**
      *  Call early in main() to allow Skia to use a JIT to accelerate CPU-bound operations.
      */