@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -233,11 +233,11 @@ public:
      *  @param tmy  The tiling mode to use when sampling in the y-direction.
      *  @param mode How to filter the tiles
      *  @param localMatrix Optional matrix used when sampling
-     *  @param tile The tile rectangle in picture coordinates: this represents the subset
-     *              (or superset) of the picture used when building a tile. It is not
-     *              affected by localMatrix and does not imply scaling (only translation
-     *              and cropping). If null, the tile rect is considered equal to the picture
-     *              bounds.
+     *  @param tileRect The tile rectangle in picture coordinates: this represents the subset
+     *                  (or superset) of the picture used when building a tile. It is not
+     *                  affected by localMatrix and does not imply scaling (only translation
+     *                  and cropping). If null, the tile rect is considered equal to the picture
+     *                  bounds.
      *  @return     Returns a new shader object. Note: this function never returns null.
      */
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode,

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkFloatingPoint.h"
 
 struct SK_API SkPoint3 {
     SkScalar fX, fY, fZ;
@@ -114,17 +114,7 @@ struct SK_API SkPoint3 {
      @return  true for values other than infinities and NaN
      */
     bool isFinite() const {
-        SkScalar accum = 0;
-        accum *= fX;
-        accum *= fY;
-        accum *= fZ;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || SkScalarIsNaN(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !SkScalarIsNaN(accum);
+        return SkIsFinite(fX, fY, fZ);
     }
 
     /** Returns the dot product of a and b, treating them as 3D vectors

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

@@ -11,6 +11,7 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 
 #include <cstdint>
@@ -269,6 +270,10 @@ public:
         @return        x-axis and y-axis radii for one corner
     */
     SkVector radii(Corner corner) const { return fRadii[corner]; }
+    /**
+     * Returns the corner radii for all four corners, in the same order as `Corner`.
+     */
+    SkSpan<const SkVector> radii() const { return SkSpan(fRadii, 4); }
 
     /** Returns bounds. Bounds may have zero width or zero height. Bounds right is
         greater than or equal to left; bounds bottom is greater than or equal to top.

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

@@ -709,18 +709,7 @@ struct SK_API SkRect {
         @return  true if no member is infinite or NaN
     */
     bool isFinite() const {
-        float accum = 0;
-        accum *= fLeft;
-        accum *= fTop;
-        accum *= fRight;
-        accum *= fBottom;
-
-        // accum is either NaN or it is finite (zero).
-        SkASSERT(0 == accum || std::isnan(accum));
-
-        // value==value will be true iff value is not NaN
-        // TODO: is it faster to say !accum or accum==accum?
-        return !std::isnan(accum);
+        return SkIsFinite(fLeft, fTop, fRight, fBottom);
     }
 
     /** Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid.
@@ -1257,14 +1246,14 @@ public:
 
     /** Sets SkRect by discarding the fractional portion of fLeft and fTop; and rounding
         up fRight and fBottom, using
-        (sk_float_floor(fLeft), sk_float_floor(fTop),
-         sk_float_ceil(fRight), sk_float_ceil(fBottom)).
+        (std::floor(fLeft), std::floor(fTop),
+         std::ceil(fRight), std::ceil(fBottom)).
 
         @param dst  storage for SkRect
     */
     void roundOut(SkRect* dst) const {
-        dst->setLTRB(sk_float_floor(fLeft), sk_float_floor(fTop),
-                     sk_float_ceil(fRight), sk_float_ceil(fBottom));
+        dst->setLTRB(std::floor(fLeft), std::floor(fTop),
+                     std::ceil(fRight), std::ceil(fBottom));
     }
 
     /** Sets SkRect by rounding up fLeft and fTop; and discarding the fractional portion

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

@@ -367,6 +367,8 @@ auto operator<<(std::basic_ostream<C, CT>& os, const sk_sp<T>& sp) -> decltype(o
     return os << sp.get();
 }
 
+template <typename T> sk_sp(T*) -> sk_sp<T>;
+
 template <typename T, typename... Args>
 sk_sp<T> sk_make_sp(Args&&... args) {
     return sk_sp<T>(new T(std::forward<Args>(args)...));

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

@@ -11,6 +11,8 @@
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkFloatingPoint.h"
 
+#include <cmath>
+
 typedef float SkScalar;
 
 #define SK_Scalar1                  1.0f
@@ -25,30 +27,30 @@ typedef float SkScalar;
 #define SK_ScalarNegativeInfinity   SK_FloatNegativeInfinity
 #define SK_ScalarNaN                SK_FloatNaN
 
-#define SkScalarFloorToScalar(x)    sk_float_floor(x)
-#define SkScalarCeilToScalar(x)     sk_float_ceil(x)
+#define SkScalarFloorToScalar(x)    std::floor(x)
+#define SkScalarCeilToScalar(x)     std::ceil(x)
 #define SkScalarRoundToScalar(x)    sk_float_round(x)
-#define SkScalarTruncToScalar(x)    sk_float_trunc(x)
+#define SkScalarTruncToScalar(x)    std::trunc(x)
 
 #define SkScalarFloorToInt(x)       sk_float_floor2int(x)
 #define SkScalarCeilToInt(x)        sk_float_ceil2int(x)
 #define SkScalarRoundToInt(x)       sk_float_round2int(x)
 
-#define SkScalarAbs(x)              sk_float_abs(x)
-#define SkScalarCopySign(x, y)      sk_float_copysign(x, y)
-#define SkScalarMod(x, y)           sk_float_mod(x,y)
-#define SkScalarSqrt(x)             sk_float_sqrt(x)
-#define SkScalarPow(b, e)           sk_float_pow(b, e)
-
-#define SkScalarSin(radians)        (float)sk_float_sin(radians)
-#define SkScalarCos(radians)        (float)sk_float_cos(radians)
-#define SkScalarTan(radians)        (float)sk_float_tan(radians)
-#define SkScalarASin(val)           (float)sk_float_asin(val)
-#define SkScalarACos(val)           (float)sk_float_acos(val)
-#define SkScalarATan2(y, x)         (float)sk_float_atan2(y,x)
-#define SkScalarExp(x)              (float)sk_float_exp(x)
-#define SkScalarLog(x)              (float)sk_float_log(x)
-#define SkScalarLog2(x)             (float)sk_float_log2(x)
+#define SkScalarAbs(x)              std::fabs(x)
+#define SkScalarCopySign(x, y)      std::copysign(x, y)
+#define SkScalarMod(x, y)           std::fmod(x,y)
+#define SkScalarSqrt(x)             std::sqrt(x)
+#define SkScalarPow(b, e)           std::pow(b, e)
+
+#define SkScalarSin(radians)        ((float)std::sin(radians))
+#define SkScalarCos(radians)        ((float)std::cos(radians))
+#define SkScalarTan(radians)        ((float)std::tan(radians))
+#define SkScalarASin(val)           ((float)std::asin(val))
+#define SkScalarACos(val)           ((float)std::acos(val))
+#define SkScalarATan2(y, x)         ((float)std::atan2(y,x))
+#define SkScalarExp(x)              ((float)std::exp(x))
+#define SkScalarLog(x)              ((float)std::log(x))
+#define SkScalarLog2(x)             ((float)std::log2(x))
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -61,20 +63,6 @@ typedef float SkScalar;
 #define SkScalarToDouble(x)     static_cast<double>(x)
 #define SkDoubleToScalar(x)     sk_double_to_float(x)
 
-static inline bool SkScalarIsNaN(SkScalar x) { return x != x; }
-
-/** Returns true if x is not NaN and not infinite
- */
-static inline bool SkScalarIsFinite(SkScalar x) { return sk_float_isfinite(x); }
-
-static inline bool SkScalarsAreFinite(SkScalar a, SkScalar b) {
-    return sk_floats_are_finite(a, b);
-}
-
-static inline bool SkScalarsAreFinite(const SkScalar array[], int count) {
-    return sk_floats_are_finite(array, count);
-}
-
 /** Returns the fractional part of the scalar. */
 static inline SkScalar SkScalarFraction(SkScalar x) {
     return x - SkScalarTruncToScalar(x);

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

@@ -21,6 +21,7 @@ class SkMatrix;
 enum class SkBlendMode;
 enum class SkTileMode;
 struct SkRect;
+struct SkSamplingOptions;
 
 /** \class SkShader
  *
@@ -90,6 +91,22 @@ SK_API sk_sp<SkShader> Color(const SkColor4f&, sk_sp<SkColorSpace>);
 SK_API sk_sp<SkShader> Blend(SkBlendMode mode, sk_sp<SkShader> dst, sk_sp<SkShader> src);
 SK_API sk_sp<SkShader> Blend(sk_sp<SkBlender>, sk_sp<SkShader> dst, sk_sp<SkShader> src);
 SK_API sk_sp<SkShader> CoordClamp(sk_sp<SkShader>, const SkRect& subset);
+
+/*
+ * Create an SkShader that will sample the 'image'. This is equivalent to SkImage::makeShader.
+ */
+SK_API sk_sp<SkShader> Image(sk_sp<SkImage> image,
+                             SkTileMode tmx, SkTileMode tmy,
+                             const SkSamplingOptions& options,
+                             const SkMatrix* localMatrix = nullptr);
+/*
+ * Create an SkShader that will sample 'image' with minimal processing. This is equivalent to
+ * SkImage::makeRawShader.
+ */
+SK_API sk_sp<SkShader> RawImage(sk_sp<SkImage> image,
+                                SkTileMode tmx, SkTileMode tmy,
+                                const SkSamplingOptions& options,
+                                const SkMatrix* localMatrix = nullptr);
 }
 
 #endif

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

@@ -9,6 +9,7 @@
 #define SkSize_DEFINED
 
 #include "include/core/SkScalar.h"
+#include "include/private/base/SkTo.h"
 
 #include <cstdint>
 
@@ -35,7 +36,7 @@ struct SkISize {
     constexpr int32_t width() const { return fWidth; }
     constexpr int32_t height() const { return fHeight; }
 
-    constexpr int64_t area() const { return fWidth * fHeight; }
+    constexpr int64_t area() const { return SkToS64(fWidth) * SkToS64(fHeight); }
 
     bool equals(int32_t w, int32_t h) const { return fWidth == w && fHeight == h; }
 };

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

@@ -138,8 +138,8 @@ public:
 
 //SkStreamMemory
     /** Returns the starting address for the data. If this cannot be done, returns NULL. */
-    //TODO: replace with virtual const SkData* getData()
     virtual const void* getMemoryBase() { return nullptr; }
+    virtual sk_sp<SkData> getData() const { return nullptr; }
 
 private:
     virtual SkStream* onDuplicate() const { return nullptr; }
@@ -392,10 +392,9 @@ public:
     */
     void setMemoryOwned(const void* data, size_t length);
 
-    sk_sp<SkData> asData() const { return fData; }
+    sk_sp<SkData> getData() const override { return fData; }
     void setData(sk_sp<SkData> data);
 
-    void skipToAlign4();
     const void* getAtPos();
 
     size_t read(void* buffer, size_t size) override;

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

@@ -9,8 +9,13 @@
 #define SkStrokeRec_DEFINED
 
 #include "include/core/SkPaint.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/base/SkMacros.h"
 
+#include <cmath>
+#include <cstdint>
+
 class SkPath;
 
 SK_BEGIN_REQUIRE_DENSE
@@ -68,7 +73,7 @@ public:
     }
 
     void setResScale(SkScalar rs) {
-        SkASSERT(rs > 0 && SkScalarIsFinite(rs));
+        SkASSERT(rs > 0 && std::isfinite(rs));
         fResScale = rs;
     }
 

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

@@ -370,7 +370,9 @@ public:
         Copies each readable pixel intersecting both rectangles, without scaling,
         converting to dst.colorType() and dst.alphaType() if required.
 
-        Pixels are readable when SkSurface is raster, or backed by a GPU.
+        Pixels are readable when SkSurface is raster, or backed by a Ganesh GPU backend. Graphite
+        has deprecated this API in favor of the equivalent asynchronous API on
+        skgpu::graphite::Context (with an optional explicit synchonization).
 
         The destination pixel storage must be allocated by the caller.
 
@@ -401,7 +403,9 @@ public:
         Copies each readable pixel intersecting both rectangles, without scaling,
         converting to dstInfo.colorType() and dstInfo.alphaType() if required.
 
-        Pixels are readable when SkSurface is raster, or backed by a GPU.
+        Pixels are readable when SkSurface is raster, or backed by a Ganesh GPU backend. Graphite
+        has deprecated this API in favor of the equivalent asynchronous API on
+        skgpu::graphite::Context (with an optional explicit synchonization).
 
         The destination pixel storage must be allocated by the caller.
 
@@ -433,7 +437,9 @@ public:
         Copies each readable pixel intersecting both rectangles, without scaling,
         converting to bitmap.colorType() and bitmap.alphaType() if required.
 
-        Pixels are readable when SkSurface is raster, or backed by a GPU.
+        Pixels are readable when SkSurface is raster, or backed by a Ganesh GPU backend. Graphite
+        has deprecated this API in favor of the equivalent asynchronous API on
+        skgpu::graphite::Context (with an optional explicit synchonization).
 
         The destination pixel storage must be allocated by the caller.
 
@@ -477,10 +483,13 @@ public:
     /** Makes surface pixel data available to caller, possibly asynchronously. It can also rescale
         the surface pixels.
 
-        Currently asynchronous reads are only supported on the GPU backend and only when the
+        Currently asynchronous reads are only supported in the Ganesh GPU backend and only when the
         underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
         other cases this operates synchronously.
 
+        For the Graphite backend this API has been deprecated in favor of the equivalent API
+        on skgpu::graphite::Context.
+
         Data is read from the source sub-rectangle, is optionally converted to a linear gamma, is
         rescaled to the size indicated by 'info', is then converted to the color space, color type,
         and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the surface

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

@@ -76,6 +76,11 @@ public:
         return SkSurfaceProps(fFlags, newPixelGeometry, fTextContrast, fTextGamma);
     }
 
+    static constexpr SkScalar kMaxContrastInclusive = 1;
+    static constexpr SkScalar kMinContrastInclusive = 0;
+    static constexpr SkScalar kMaxGammaExclusive = 4;
+    static constexpr SkScalar kMinGammaInclusive = 0;
+
     uint32_t flags() const { return fFlags; }
     SkPixelGeometry pixelGeometry() const { return fPixelGeometry; }
     SkScalar textContrast() const { return fTextContrast; }

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

@@ -8,7 +8,9 @@
 #ifndef SkSwizzle_DEFINED
 #define SkSwizzle_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
 
 /**
   Swizzles byte order of |count| 32-bit pixels, swapping R and B.

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

@@ -11,6 +11,7 @@
 #include "include/core/SkFontArguments.h"
 #include "include/core/SkFontParameters.h"
 #include "include/core/SkFontStyle.h"
+#include "include/core/SkFourByteTag.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkString.h"

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

@@ -23,7 +23,6 @@
 #include "include/private/base/SkDebug.h"
 // IWYU pragma: end_exports
 
-#include <climits>
 #include <cstdint>
 
 #if !defined(SK_GANESH) && !defined(SK_GRAPHITE)
@@ -154,7 +153,7 @@
 #endif
 
 #if !defined(GR_GPU_STATS)
-  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS) || defined(GR_TEST_UTILS)
+  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS) || defined(GPU_TEST_UTILS)
       #define GR_GPU_STATS    1
   #else
       #define GR_GPU_STATS    0
@@ -163,13 +162,6 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-typedef uint32_t SkFourByteTag;
-static inline constexpr SkFourByteTag SkSetFourByteTag(char a, char b, char c, char d) {
-    return (((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | (uint32_t)d);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 /** 32 bit integer to hold a unicode value
 */
 typedef int32_t SkUnichar;
@@ -178,15 +170,6 @@ typedef int32_t SkUnichar;
 */
 typedef uint16_t SkGlyphID;
 
-/** 32 bit value to hold a millisecond duration
-    Note that SK_MSecMax is about 25 days.
-*/
-typedef uint32_t SkMSec;
-
-/** Maximum representable milliseconds; 24d 20h 31m 23.647s.
-*/
-static constexpr SkMSec SK_MSecMax = INT32_MAX;
-
 /** The generation IDs in Skia reserve 0 has an invalid marker.
 */
 static constexpr uint32_t SK_InvalidGenID = 0;
@@ -195,5 +178,4 @@ static constexpr uint32_t SK_InvalidGenID = 0;
 */
 static constexpr uint32_t SK_InvalidUniqueID = 0;
 
-
 #endif

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

@@ -5,15 +5,14 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-
-
-
-
-
 #ifndef SkUnPreMultiply_DEFINED
 #define SkUnPreMultiply_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkCPUTypes.h"
+
+#include <cstdint>
 
 class SK_API SkUnPreMultiply {
 public:

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

@@ -9,13 +9,15 @@
 #define SkVertices_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 
-class SkData;
-struct SkPoint;
 class SkVerticesPriv;
 
 /**

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -4,22 +4,25 @@
 #define SkPDFDocument_DEFINED
 
 #include "include/core/SkDocument.h"
-
-#include <vector>
-
-#include "include/core/SkColor.h"
 #include "include/core/SkMilestone.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkString.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkNoncopyable.h"
-#include "src/base/SkTime.h"
 
-#define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
-#define SKPDF_STRING_IMPL(X) #X
+#include <cstdint>
+#include <memory>
+#include <vector>
 
+class SkCanvas;
 class SkExecutor;
 class SkPDFArray;
 class SkPDFTagTree;
+class SkWStream;
+
+#define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
+#define SKPDF_STRING_IMPL(X) #X
 
 namespace SkPDF {
 
@@ -179,15 +182,9 @@ struct Metadata {
         HighButSlow = 9,
     } fCompressionLevel = CompressionLevel::Default;
 
-    /** Preferred Subsetter. Only respected if both are compiled in.
-
-        The Sfntly subsetter is deprecated.
-
-        Experimental.
-    */
+    /** Preferred Subsetter. */
     enum Subsetter {
         kHarfbuzz_Subsetter,
-        kSfntly_Subsetter,
     } fSubsetter = kHarfbuzz_Subsetter;
 };
 

package/cpp/skia/include/effects/SkHighContrastFilter.h

@@ -37,16 +37,16 @@ struct SkHighContrastConfig {
     SkHighContrastConfig(bool grayscale,
                          InvertStyle invertStyle,
                          SkScalar contrast)
-        : fGrayscale(grayscale),
-          fInvertStyle(invertStyle),
-          fContrast(contrast) {}
+        : fGrayscale(grayscale)
+        , fInvertStyle(invertStyle)
+        , fContrast(contrast) {}
 
     // Returns true if all of the fields are set within the valid range.
     bool isValid() const {
         return fInvertStyle >= InvertStyle::kNoInvert &&
-            fInvertStyle <= InvertStyle::kInvertLightness &&
-            fContrast >= -1.0 &&
-            fContrast <= 1.0;
+               fInvertStyle <= InvertStyle::kInvertLightness &&
+               fContrast >= -1.0 &&
+               fContrast <= 1.0;
     }
 
     // If true, the color will be converted to grayscale.