@shopify/react-native-skia 0.1.212 → 0.1.214

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

@@ -17,6 +17,10 @@ class SkData;
 class SkImage;
 class SkPicture;
 class SkTypeface;
+class SkReadBuffer;
+namespace sktext::gpu {
+    class Slug;
+}
 
 /**
  *  A serial-proc is asked to serialize the specified object (e.g. picture or image).
@@ -49,6 +53,13 @@ using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t leng
  */
 using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data, size_t length, void* ctx);
 
+/**
+ * Slugs are currently only deserializable with a GPU backend. Clients will not be able to
+ * provide a custom mechanism here, but can enable Slug deserialization by calling
+ * sktext::gpu::AddDeserialProcs to add Skia's implementation.
+ */
+using SkSlugProc = sk_sp<sktext::gpu::Slug> (*)(SkReadBuffer&, void* ctx);
+
 /**
  *  Called with the encoded form of a typeface (previously written with a custom
  *  SkSerialTypefaceProc proc). Return a typeface object, or nullptr indicating failure.
@@ -73,6 +84,9 @@ struct SK_API SkDeserialProcs {
     SkDeserialImageProc     fImageProc = nullptr;
     void*                   fImageCtx = nullptr;
 
+    SkSlugProc              fSlugProc = nullptr;
+    void*                   fSlugCtx = nullptr;
+
     SkDeserialTypefaceProc  fTypefaceProc = nullptr;
     void*                   fTypefaceCtx = nullptr;
 

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

@@ -67,6 +67,15 @@ public:
      */
     sk_sp<SkShader> makeWithColorFilter(sk_sp<SkColorFilter>) const;
 
+    /**
+     *  Return a shader that will compute this shader in a specific color space.
+     *  By default, all shaders operate in the destination (surface) color space.
+     *  The results of a shader are still always converted to the destination - this
+     *  API has no impact on simple shaders or images. Primarily, it impacts shaders
+     *  that perform mathematical operations, like Blend shaders, or runtime shaders.
+     */
+    sk_sp<SkShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace>) const;
+
 private:
     SkShader() = default;
     friend class SkShaderBase;

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

@@ -86,22 +86,22 @@ public:
      */
     virtual bool isAtEnd() const = 0;
 
-    bool SK_WARN_UNUSED_RESULT readS8(int8_t*);
-    bool SK_WARN_UNUSED_RESULT readS16(int16_t*);
-    bool SK_WARN_UNUSED_RESULT readS32(int32_t*);
+    [[nodiscard]] bool readS8(int8_t*);
+    [[nodiscard]] bool readS16(int16_t*);
+    [[nodiscard]] bool readS32(int32_t*);
 
-    bool SK_WARN_UNUSED_RESULT readU8(uint8_t* i) { return this->readS8((int8_t*)i); }
-    bool SK_WARN_UNUSED_RESULT readU16(uint16_t* i) { return this->readS16((int16_t*)i); }
-    bool SK_WARN_UNUSED_RESULT readU32(uint32_t* i) { return this->readS32((int32_t*)i); }
+    [[nodiscard]] bool readU8(uint8_t* i) { return this->readS8((int8_t*)i); }
+    [[nodiscard]] bool readU16(uint16_t* i) { return this->readS16((int16_t*)i); }
+    [[nodiscard]] bool readU32(uint32_t* i) { return this->readS32((int32_t*)i); }
 
-    bool SK_WARN_UNUSED_RESULT readBool(bool* b) {
+    [[nodiscard]] bool readBool(bool* b) {
         uint8_t i;
         if (!this->readU8(&i)) { return false; }
         *b = (i != 0);
         return true;
     }
-    bool SK_WARN_UNUSED_RESULT readScalar(SkScalar*);
-    bool SK_WARN_UNUSED_RESULT readPackedUInt(size_t*);
+    [[nodiscard]] bool readScalar(SkScalar*);
+    [[nodiscard]] bool readPackedUInt(size_t*);
 
 //SkStreamRewindable
     /** Rewinds to the beginning of the stream. Returns true if the stream is known

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

@@ -16,8 +16,8 @@
 
 #include <atomic>
 #include <cstdarg>
-#include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <string>
 #include <string_view>
 #include <type_traits>

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

@@ -39,12 +39,6 @@ namespace skgpu::graphite {
 class Recorder;
 }
 
-#if !defined(SK_DISABLE_LEGACY_SKSURFACE_FLUSH)
-enum class GrSemaphoresSubmitted : bool;
-struct GrFlushInfo;
-namespace skgpu { class MutableTextureState; }
-#endif
-
 namespace SkSurfaces {
 
 enum class BackendSurfaceAccess {
@@ -555,6 +549,20 @@ public:
                                          ReadPixelsCallback callback,
                                          ReadPixelsContext context);
 
+    /**
+     * Identical to asyncRescaleAndReadPixelsYUV420 but a fourth plane is returned in the
+     * AsyncReadResult passed to 'callback'. The fourth plane contains the alpha chanel at the
+     * same full resolution as the Y plane.
+     */
+    void asyncRescaleAndReadPixelsYUVA420(SkYUVColorSpace yuvColorSpace,
+                                          sk_sp<SkColorSpace> dstColorSpace,
+                                          const SkIRect& srcRect,
+                                          const SkISize& dstSize,
+                                          RescaleGamma rescaleGamma,
+                                          RescaleMode rescaleMode,
+                                          ReadPixelsCallback callback,
+                                          ReadPixelsContext context);
+
     /** Copies SkRect of pixels from the src SkPixmap to the SkSurface.
 
         Source SkRect corners are (0, 0) and (src.width(), src.height()).
@@ -643,25 +651,6 @@ private:
     uint32_t             fGenerationID;
 
     using INHERITED = SkRefCnt;
-
-public:
-#if !defined(SK_DISABLE_LEGACY_SKSURFACE_FLUSH) && defined(SK_GANESH)
-    using BackendSurfaceAccess = SkSurfaces::BackendSurfaceAccess;
-    GrSemaphoresSubmitted flush(BackendSurfaceAccess access, const GrFlushInfo& info);
-    GrSemaphoresSubmitted flush(const GrFlushInfo& info,
-                                const skgpu::MutableTextureState* newState = nullptr);
-    void resolveMSAA();
-#endif
-
-#if !defined(SK_DISABLE_LEGACY_SKSURFACE_FLUSH)
-    void flushAndSubmit(bool syncCpu = false);
-    void flush();
-#endif
-
-#if !defined(SK_DISABLE_LEGACY_SKSURFACE_AS_IMAGE) && defined(SK_GRAPHITE)
-    sk_sp<SkImage> asImage();
-#endif
-
 };
 
 #endif

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

@@ -9,16 +9,25 @@
 #define SkTextBlob_DEFINED
 
 #include "include/core/SkFont.h"
-#include "include/core/SkPaint.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkString.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTemplates.h"
 
 #include <atomic>
+#include <cstdint>
+#include <cstring>
 
+class SkData;
+class SkPaint;
+class SkTypeface;
+struct SkDeserialProcs;
+struct SkPoint;
 struct SkRSXform;
 struct SkSerialProcs;
-struct SkDeserialProcs;
 
 namespace sktext {
 class GlyphRunList;
@@ -248,10 +257,13 @@ private:
 
     static unsigned ScalarsPerGlyph(GlyphPositioning pos);
 
+    using PurgeDelegate = void (*)(uint32_t blobID, uint32_t cacheID);
+
     // Call when this blob is part of the key to a cache entry. This allows the cache
     // to know automatically those entries can be purged when this SkTextBlob is deleted.
-    void notifyAddedToCache(uint32_t cacheID) const {
+    void notifyAddedToCache(uint32_t cacheID, PurgeDelegate purgeDelegate) const {
         fCacheID.store(cacheID);
+        fPurgeDelegate.store(purgeDelegate);
     }
 
     friend class sktext::GlyphRunList;
@@ -262,6 +274,7 @@ private:
     const SkRect                  fBounds;
     const uint32_t                fUniqueID;
     mutable std::atomic<uint32_t> fCacheID;
+    mutable std::atomic<PurgeDelegate> fPurgeDelegate;
 
     SkDEBUGCODE(size_t fStorageSize;)
 

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

@@ -15,8 +15,18 @@
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+
 class SkPaint;
 
+/** \namespace SkTiledImageUtils
+    SkTiledImageUtils' DrawImage/DrawImageRect methods are intended to be direct replacements
+    for their SkCanvas equivalents. The SkTiledImageUtils calls will break SkBitmap-backed
+    SkImages into smaller tiles and draw them if the original image is too large to be
+    uploaded to the GPU. If the original image doesn't need tiling or is already gpu-backed
+    the DrawImage/DrawImageRect calls will fall through to the matching SkCanvas call.
+*/
 namespace SkTiledImageUtils {
 
 SK_API void DrawImageRect(SkCanvas* canvas,
@@ -92,6 +102,24 @@ inline void DrawImage(SkCanvas* canvas,
     DrawImage(canvas, image.get(), x, y, sampling, paint, constraint);
 }
 
+static constexpr int kNumImageKeyValues = 6;
+
+/** Retrieves a set of values that can be used as part of a cache key for the provided image.
+
+    Unfortunately, SkImage::uniqueID isn't sufficient as an SkImage cache key. In particular,
+    SkBitmap-backed SkImages can share a single SkBitmap and refer to different subsets of it.
+    In this situation the optimal key is based on the SkBitmap's generation ID and the subset
+    rectangle.
+    For Picture-backed images this method will attempt to generate a concise internally-based
+    key (i.e., containing picture ID, matrix translation, width and height, etc.). For complicated
+    Picture-backed images (i.e., those w/ a paint or a full matrix) it will fall back to
+    using 'image's unique key.
+
+    @param image     The image for which key values are desired
+    @param keyValues The resulting key values
+*/
+SK_API void GetImageKeyValues(const SkImage* image, uint32_t keyValues[kNumImageKeyValues]);
+
 }  // namespace SkTiledImageUtils
 
 #endif // SkTiledImageUtils_DEFINED

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

@@ -11,20 +11,25 @@
 #include "include/core/SkFontArguments.h"
 #include "include/core/SkFontParameters.h"
 #include "include/core/SkFontStyle.h"
-#include "include/core/SkFontTypes.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkString.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkWeakRefCnt.h"
 #include "include/private/base/SkOnce.h"
 
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
 class SkData;
 class SkDescriptor;
-class SkFontData;
 class SkFontDescriptor;
 class SkScalerContext;
 class SkStream;
 class SkStreamAsset;
 class SkWStream;
+enum class SkTextEncoding;
 struct SkAdvancedTypefaceMetrics;
 struct SkScalerContextEffects;
 struct SkScalerContextRec;

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

@@ -26,11 +26,7 @@
 #include <climits>
 #include <cstdint>
 
-#if defined(SK_GANESH) || defined(SK_GRAPHITE)
-#  if !defined(SK_ENABLE_SKSL)
-#    define SK_ENABLE_SKSL
-#  endif
-#else
+#if !defined(SK_GANESH) && !defined(SK_GRAPHITE)
 #  undef SK_GL
 #  undef SK_VULKAN
 #  undef SK_METAL
@@ -90,11 +86,6 @@
     #define SK_GAMMA_EXPONENT (0.0f)  // SRGB
 #endif
 
-#ifndef GR_TEST_UTILS
-#  define GR_TEST_UTILS 0
-#endif
-
-
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
@@ -142,7 +133,8 @@
 #endif
 
 /**
- *  Gr defines are set to 0 or 1, rather than being undefined or defined
+ *  These defines are set to 0 or 1, rather than being undefined or defined
+ *  TODO: consider updating these for consistency
  */
 
 #if !defined(GR_CACHE_STATS)
@@ -154,7 +146,7 @@
 #endif
 
 #if !defined(GR_GPU_STATS)
-  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS) || GR_TEST_UTILS
+  #if defined(SK_DEBUG) || defined(SK_DUMP_STATS) || defined(GR_TEST_UTILS)
       #define GR_GPU_STATS    1
   #else
       #define GR_GPU_STATS    0

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

@@ -11,8 +11,8 @@
 #include "include/core/SkMilestone.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkString.h"
-#include "include/core/SkTime.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
@@ -63,6 +63,20 @@ struct StructureElementNode {
     SkString fLang;
 };
 
+struct DateTime {
+    int16_t  fTimeZoneMinutes;  // The number of minutes that this
+                                // is ahead of or behind UTC.
+    uint16_t fYear;          //!< e.g. 2005
+    uint8_t  fMonth;         //!< 1..12
+    uint8_t  fDayOfWeek;     //!< 0..6, 0==Sunday
+    uint8_t  fDay;           //!< 1..31
+    uint8_t  fHour;          //!< 0..23
+    uint8_t  fMinute;        //!< 0..59
+    uint8_t  fSecond;        //!< 0..59
+
+    void toISO8601(SkString* dst) const;
+};
+
 /** Optional metadata to be passed into the PDF factory function.
 */
 struct Metadata {
@@ -96,12 +110,12 @@ struct Metadata {
     /** The date and time the document was created.
         The zero default value represents an unknown/unset time.
     */
-    SkTime::DateTime fCreation = {0, 0, 0, 0, 0, 0, 0, 0};
+    DateTime fCreation = {0, 0, 0, 0, 0, 0, 0, 0};
 
     /** The date and time the document was most recently modified.
         The zero default value represents an unknown/unset time.
     */
-    SkTime::DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
+    DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
 
     /** The DPI (pixels-per-inch) at which features without native PDF support
         will be rasterized (e.g. draw image with perspective, draw text with

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

@@ -8,52 +8,69 @@
 #ifndef SkImageFilters_DEFINED
 #define SkImageFilters_DEFINED
 
-#include "include/core/SkBlendMode.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkImage.h"
 #include "include/core/SkImageFilter.h"
 #include "include/core/SkPicture.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkShader.h"
 #include "include/core/SkTileMode.h"
 #include "include/core/SkTypes.h"
-#include "include/effects/SkRuntimeEffect.h"
 
 #include <cstddef>
+#include <optional>
+#include <string_view>
+#include <utility>
 
 class SkBlender;
 class SkColorFilter;
-class SkPaint;
-class SkRegion;
-
-namespace skif {
-  static constexpr SkRect kNoCropRect = {SK_ScalarNegativeInfinity, SK_ScalarNegativeInfinity,
-                                         SK_ScalarInfinity, SK_ScalarInfinity};
-}
+class SkMatrix;
+class SkRuntimeShaderBuilder;
+enum class SkBlendMode;
+struct SkIPoint;
+struct SkISize;
+struct SkPoint3;
+struct SkSamplingOptions;
 
 // A set of factory functions providing useful SkImageFilter effects. For image filters that take an
 // input filter, providing nullptr means it will automatically use the dynamic source image. This
 // source depends on how the filter is applied, but is either the contents of a saved layer when
-// drawing with SkCanvas, or an explicit SkImage if using SkImage::makeWithFilter.
+// drawing with SkCanvas, or an explicit SkImage if using one of the SkImages::MakeWithFilter
+// factories.
 class SK_API SkImageFilters {
 public:
     // This is just a convenience type to allow passing SkIRects, SkRects, and optional pointers
     // to those types as a crop rect for the image filter factories. It's not intended to be used
     // directly.
-    struct CropRect {
-        CropRect() : fCropRect(skif::kNoCropRect) {}
+    struct CropRect : public std::optional<SkRect> {
+        CropRect() {}
         // Intentionally not explicit so callers don't have to use this type but can use SkIRect or
         // SkRect as desired.
-        CropRect(std::nullptr_t) : fCropRect(skif::kNoCropRect) {}
-        CropRect(const SkIRect& crop) : fCropRect(SkRect::Make(crop)) {}
-        CropRect(const SkRect& crop) : fCropRect(crop) {}
-        CropRect(const SkIRect* optionalCrop) : fCropRect(optionalCrop ? SkRect::Make(*optionalCrop)
-                                                                       : skif::kNoCropRect) {}
-        CropRect(const SkRect* optionalCrop) : fCropRect(optionalCrop ? *optionalCrop
-                                                                      : skif::kNoCropRect) {}
-
-        operator const SkRect*() const { return fCropRect == skif::kNoCropRect ? nullptr : &fCropRect; }
+        CropRect(const SkIRect& crop) : std::optional<SkRect>(SkRect::Make(crop)) {}
+        CropRect(const SkRect& crop) : std::optional<SkRect>(crop) {}
+        CropRect(const std::optional<SkRect>& crop) : std::optional<SkRect>(crop) {}
+        CropRect(const std::nullopt_t&) : std::optional<SkRect>() {}
+
+        // Backwards compatibility for when the APIs used to explicitly accept "const SkRect*"
+        CropRect(std::nullptr_t) {}
+        CropRect(const SkIRect* optionalCrop) {
+            if (optionalCrop) {
+                *this = SkRect::Make(*optionalCrop);
+            }
+        }
+        CropRect(const SkRect* optionalCrop) {
+            if (optionalCrop) {
+                *this = *optionalCrop;
+            }
+        }
 
-        SkRect fCropRect;
+        // std::optional doesn't define == when comparing to another optional...
+        bool operator==(const CropRect& o) const {
+            return this->has_value() == o.has_value() &&
+                   (!this->has_value() || this->value() == *o);
+        }
     };
 
     /**
@@ -128,6 +145,27 @@ public:
      */
     static sk_sp<SkImageFilter> Compose(sk_sp<SkImageFilter> outer, sk_sp<SkImageFilter> inner);
 
+    /**
+     *  Create a filter that applies a crop to the result of the 'input' filter. Pixels within the
+     *  crop rectangle are unmodified from what 'input' produced. Pixels outside of crop match the
+     *  provided SkTileMode (defaulting to kDecal).
+     *
+     *  NOTE: The optional CropRect argument for many of the factories is equivalent to creating the
+     *  filter without a CropRect and then wrapping it in ::Crop(rect, kDecal). Explicitly adding
+     *  Crop filters lets you control their tiling and use different geometry for the input and the
+     *  output of another filter.
+     *
+     *  @param rect     The cropping geometry
+     *  @param tileMode The tilemode applied to pixels *outside* of 'crop'
+     *  @param input    The input filter that is cropped, uses source image if this is null
+    */
+    static sk_sp<SkImageFilter> Crop(const SkRect& rect,
+                                     SkTileMode tileMode,
+                                     sk_sp<SkImageFilter> input);
+    static sk_sp<SkImageFilter> Crop(const SkRect& rect, sk_sp<SkImageFilter> input) {
+        return Crop(rect, SkTileMode::kDecal, std::move(input));
+    }
+
     /**
      *  Create a filter that moves each pixel in its color input based on an (x,y) vector encoded
      *  in its displacement input filter. Two color components of the displacement image are
@@ -179,6 +217,11 @@ public:
                                                SkColor color, sk_sp<SkImageFilter> input,
                                                const CropRect& cropRect = {});
 
+    /**
+     * Create a filter that always produces transparent black.
+     */
+    static sk_sp<SkImageFilter> Empty();
+
     /**
      *  Create a filter that draws the 'srcRect' portion of image into 'dstRect' using the given
      *  filter quality. Similar to SkCanvas::drawImageRect. The returned image filter evaluates
@@ -311,7 +354,6 @@ public:
         return Picture(std::move(pic), target);
     }
 
-#ifdef SK_ENABLE_SKSL
     /**
      *  Create a filter that fills the output with the per-pixel evaluation of the SkShader produced
      *  by the SkRuntimeShaderBuilder. The shader is defined in the image filter's local coordinate
@@ -320,6 +362,8 @@ public:
      *  This variant assumes that the runtime shader samples 'childShaderName' with the same input
      *  coordinate passed to to shader.
      *
+     *  This requires a GPU backend or SkSL to be compiled in.
+     *
      *  @param builder         The builder used to produce the runtime shader, that will in turn
      *                         fill the result image
      *  @param childShaderName The name of the child shader defined in the builder that will be
@@ -343,6 +387,8 @@ public:
      *
      * This allows Skia to provide sampleable values for the image filter without worrying about
      * boundary conditions.
+     *
+     * This requires a GPU backend or SkSL to be compiled in.
     */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
                                               SkScalar sampleRadius,
@@ -354,6 +400,8 @@ public:
      *  by the SkRuntimeShaderBuilder. The shader is defined in the image filter's local coordinate
      *  system, so it will automatically be affected by SkCanvas' transform.
      *
+     *  This requires a GPU backend or SkSL to be compiled in.
+     *
      *  @param builder          The builder used to produce the runtime shader, that will in turn
      *                          fill the result image
      *  @param childShaderNames The names of the child shaders defined in the builder that will be
@@ -378,13 +426,14 @@ public:
      * inform Skia that the runtime shader guarantees that all dynamic children (defined in
      * childShaderNames) will be evaluated with coordinates at most 'maxSampleRadius' away from the
      * coordinate provided to the runtime shader itself.
+     *
+     *  This requires a GPU backend or SkSL to be compiled in.
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
                                               SkScalar maxSampleRadius,
                                               std::string_view childShaderNames[],
                                               const sk_sp<SkImageFilter> inputs[],
                                               int inputCount);
-#endif  // SK_ENABLE_SKSL
 
     enum class Dither : bool {
         kNo = false,