@shopify/react-native-skia 0.1.212 → 0.1.214

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

@@ -44,19 +44,6 @@ struct SkSamplingOptions;
 
 namespace skgpu::graphite { class Recorder; }
 
-#if !defined(SK_DISABLE_LEGACY_GRAPHITE_IMAGE_FACTORIES) && defined(SK_GRAPHITE)
-#include "include/gpu/graphite/GraphiteTypes.h"
-
-namespace skgpu { enum class Mipmapped : bool; }
-namespace skgpu::graphite {
-class BackendTexture;
-class Recorder;
-class TextureInfo;
-enum class Volatile : bool;
-class YUVABackendTextures;
-}
-#endif
-
 namespace SkImages {
 
 /** Caller data passed to RasterReleaseProc; may be nullptr. */
@@ -229,6 +216,34 @@ SK_API sk_sp<SkImage> RasterFromData(const SkImageInfo& info,
                                      sk_sp<SkData> pixels,
                                      size_t rowBytes);
 
+/** Creates a filtered SkImage on the CPU. filter processes the src image, potentially changing
+    the color, position, and size. subset is the bounds of src that are processed
+    by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset
+    is required storage for the actual bounds of the filtered SkImage. offset is
+    required storage for translation of returned SkImage.
+
+    Returns nullptr a filtered result could not be created. If nullptr is returned, outSubset
+    and offset are undefined.
+
+    Useful for animation of SkImageFilter that varies size from frame to frame.
+    outSubset describes the valid bounds of returned image. offset translates the returned SkImage
+    to keep subsequent animation frames aligned with respect to each other.
+
+    @param src         the image to be filtered
+    @param filter      the image filter to be applied
+    @param subset      bounds of SkImage processed by filter
+    @param clipBounds  expected bounds of filtered SkImage
+    @param outSubset   storage for returned SkImage bounds
+    @param offset      storage for returned SkImage translation
+    @return            filtered SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> MakeWithFilter(sk_sp<SkImage> src,
+                                     const SkImageFilter* filter,
+                                     const SkIRect& subset,
+                                     const SkIRect& clipBounds,
+                                     SkIRect* outSubset,
+                                     SkIPoint* offset);
+
 }  // namespace SkImages
 
 /** \class SkImage
@@ -642,6 +657,20 @@ public:
                                          ReadPixelsCallback callback,
                                          ReadPixelsContext context) const;
 
+    /**
+     * 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) const;
+
     /** Copies SkImage to dst, scaling pixels to fit dst.width() and dst.height(), and
         converting pixels to match dst.colorType() and dst.alphaType(). Returns true if
         pixels are copied. Returns false if dst.addr() is nullptr, or dst.rowBytes() is
@@ -696,14 +725,18 @@ public:
     */
     virtual sk_sp<SkImage> makeSubset(GrDirectContext* direct, const SkIRect& subset) const = 0;
 
-#if !defined(SK_DISABLE_LEGACY_IMAGE_SUBSET_METHODS)
-    sk_sp<SkImage> makeSubset(const SkIRect& subset, GrDirectContext* direct = nullptr) const {
-        return this->makeSubset(direct, subset);
-    }
-#endif
-
     struct RequiredProperties {
         bool fMipmapped;
+
+        bool operator==(const RequiredProperties& other) const {
+            return fMipmapped == other.fMipmapped;
+        }
+
+        bool operator!=(const RequiredProperties& other) const { return !(*this == other); }
+
+        bool operator<(const RequiredProperties& other) const {
+            return fMipmapped < other.fMipmapped;
+        }
     };
 
     /** Returns subset of this image.
@@ -733,6 +766,11 @@ public:
      */
     bool hasMipmaps() const;
 
+    /**
+     *  Returns true if the image holds protected content.
+     */
+    bool isProtected() const;
+
     /**
      *  Returns an image with the same "base" pixels as the this image, but with mipmap levels
      *  automatically generated and attached.
@@ -773,37 +811,6 @@ public:
     }
 #endif
 
-    /** Creates filtered SkImage. filter processes original SkImage, potentially changing
-        color, position, and size. subset is the bounds of original SkImage processed
-        by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset
-        is required storage for the actual bounds of the filtered SkImage. offset is
-        required storage for translation of returned SkImage.
-
-        Returns nullptr if SkImage could not be created or if the recording context provided doesn't
-        match the GPU context in which the image was created. If nullptr is returned, outSubset
-        and offset are undefined.
-
-        Useful for animation of SkImageFilter that varies size from frame to frame.
-        Returned SkImage is created larger than required by filter so that GPU texture
-        can be reused with different sized effects. outSubset describes the valid bounds
-        of GPU texture returned. offset translates the returned SkImage to keep subsequent
-        animation frames aligned with respect to each other.
-
-        @param context     the GrRecordingContext in play - if it exists
-        @param filter      how SkImage is sampled when transformed
-        @param subset      bounds of SkImage processed by filter
-        @param clipBounds  expected bounds of filtered SkImage
-        @param outSubset   storage for returned SkImage bounds
-        @param offset      storage for returned SkImage translation
-        @return            filtered SkImage, or nullptr
-    */
-    virtual sk_sp<SkImage> makeWithFilter(GrRecordingContext* context,
-                                          const SkImageFilter* filter,
-                                          const SkIRect& subset,
-                                          const SkIRect& clipBounds,
-                                          SkIRect* outSubset,
-                                          SkIPoint* offset) const = 0;
-
     /** Deprecated.
      */
     enum LegacyBitmapMode {
@@ -852,11 +859,6 @@ public:
     virtual sk_sp<SkImage> makeColorSpace(GrDirectContext* direct,
                                           sk_sp<SkColorSpace> target) const = 0;
 
-#if !defined(SK_DISABLE_LEGACY_IMAGE_COLORSPACE_METHODS)
-    sk_sp<SkImage> makeColorSpace(sk_sp<SkColorSpace> target,
-                                  GrDirectContext* direct = nullptr) const;
-#endif
-
     /** Creates SkImage in target SkColorSpace.
         Returns nullptr if SkImage could not be created.
 
@@ -893,12 +895,6 @@ public:
                                                       SkColorType targetColorType,
                                                       sk_sp<SkColorSpace> targetCS) const = 0;
 
-#if !defined(SK_DISABLE_LEGACY_IMAGE_COLORSPACE_METHODS)
-    sk_sp<SkImage> makeColorTypeAndColorSpace(SkColorType targetColorType,
-                                              sk_sp<SkColorSpace> targetColorSpace,
-                                              GrDirectContext* direct = nullptr) const;
-#endif
-
     /** Experimental.
         Creates SkImage in target SkColorType and SkColorSpace.
         Returns nullptr if SkImage could not be created.
@@ -938,56 +934,6 @@ private:
     sk_sp<SkImage> withMipmaps(sk_sp<SkMipmap>) const;
 
     using INHERITED = SkRefCnt;
-
-public:
-#if !defined(SK_DISABLE_LEGACY_IMAGE_RELEASE_PROCS)
-    using ReleaseContext = SkImages::ReleaseContext;
-    using TextureReleaseProc = void (*)(ReleaseContext);
-#endif
-#if !defined(SK_DISABLE_LEGACY_GRAPHITE_IMAGE_METHODS) && defined(SK_GRAPHITE)
-    struct RequiredImageProperties {
-        skgpu::Mipmapped fMipmapped;
-    };
-
-    sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*, RequiredImageProperties) const;
-#endif
-#if !defined(SK_DISABLE_LEGACY_GRAPHITE_IMAGE_FACTORIES) && defined(SK_GRAPHITE)
-    // Passed to both fulfill and imageRelease
-    using GraphitePromiseImageContext = void*;
-    // Returned from fulfill and passed into textureRelease
-    using GraphitePromiseTextureReleaseContext = void*;
-
-    using GraphitePromiseImageFulfillProc =
-            std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext>
-            (*)(GraphitePromiseImageContext);
-    using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
-    using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);
-
-    static sk_sp<SkImage> MakeGraphitePromiseTexture(skgpu::graphite::Recorder*,
-                                                     SkISize,
-                                                     const skgpu::graphite::TextureInfo&,
-                                                     const SkColorInfo&,
-                                                     skgpu::graphite::Volatile,
-                                                     GraphitePromiseImageFulfillProc,
-                                                     GraphitePromiseImageReleaseProc,
-                                                     GraphitePromiseTextureReleaseProc,
-                                                     GraphitePromiseImageContext);
-
-    static sk_sp<SkImage> MakeGraphiteFromBackendTexture(skgpu::graphite::Recorder*,
-                                                         const skgpu::graphite::BackendTexture&,
-                                                         SkColorType,
-                                                         SkAlphaType,
-                                                         sk_sp<SkColorSpace>,
-                                                         TextureReleaseProc = nullptr,
-                                                         ReleaseContext = nullptr);
-
-    static sk_sp<SkImage> MakeGraphiteFromYUVABackendTextures(
-            skgpu::graphite::Recorder*,
-            const skgpu::graphite::YUVABackendTextures&,
-            sk_sp<SkColorSpace>,
-            TextureReleaseProc = nullptr,
-            ReleaseContext = nullptr);
-#endif
 };
 
 #endif

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

@@ -9,10 +9,15 @@
 #define SkImageFilter_DEFINED
 
 #include "include/core/SkFlattenable.h"
-#include "include/core/SkMatrix.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
 
 class SkColorFilter;
+class SkMatrix;
+struct SkDeserialProcs;
 
 /**
  *  Base class for image filters. If one is installed in the paint, then all drawing occurs as

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

@@ -59,6 +59,13 @@ public:
         return this->onIsValid(context);
     }
 
+    /**
+     *  Will this generator produce protected content
+     */
+    bool isProtected() const {
+        return this->onIsProtected();
+    }
+
     /**
      *  Decode into the given pixels, a block of memory of size at
      *  least (info.fHeight - 1) * rowBytes + (info.fWidth *
@@ -122,6 +129,7 @@ protected:
     struct Options {};
     virtual bool onGetPixels(const SkImageInfo&, void*, size_t, const Options&) { return false; }
     virtual bool onIsValid(GrRecordingContext*) const { return true; }
+    virtual bool onIsProtected() const { return false; }
     virtual bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
                                  SkYUVAPixmapInfo*) const { return false; }
     virtual bool onGetYUVAPlanes(const SkYUVAPixmaps&) { return false; }

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

@@ -550,8 +550,6 @@ public:
 
         @param rowBytes  size of pixel row or larger
         @return          memory required by pixel buffer
-
-        example: https://fiddle.skia.org/c/@ImageInfo_computeByteSize
     */
     size_t computeByteSize(size_t rowBytes) const;
 

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

@@ -9,8 +9,12 @@
 #define SkM44_DEFINED
 
 #include "include/core/SkMatrix.h"
-#include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+#include <cstring>
+
+struct SkRect;
 
 struct SK_API SkV2 {
     float x, y;
@@ -376,9 +380,9 @@ public:
     /** If this is invertible, return that in inverse and return true. If it is
      *  not invertible, return false and leave the inverse parameter unchanged.
      */
-    bool SK_WARN_UNUSED_RESULT invert(SkM44* inverse) const;
+    [[nodiscard]] bool invert(SkM44* inverse) const;
 
-    SkM44 SK_WARN_UNUSED_RESULT transpose() const;
+    [[nodiscard]] SkM44 transpose() const;
 
     void dump() const;
 

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

@@ -8,10 +8,13 @@
 #ifndef SkMallocPixelRef_DEFINED
 #define SkMallocPixelRef_DEFINED
 
-#include "include/core/SkPixelRef.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
+
+#include <cstddef>
+
 class SkData;
+class SkPixelRef;
 struct SkImageInfo;
 
 /** We explicitly use the same allocator for our pixels that SkMask does,

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

@@ -71,7 +71,7 @@ public:
         @param sy  vertical scale factor
         @return    SkMatrix with scale
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT Scale(SkScalar sx, SkScalar sy) {
+    [[nodiscard]] static SkMatrix Scale(SkScalar sx, SkScalar sy) {
         SkMatrix m;
         m.setScale(sx, sy);
         return m;
@@ -87,30 +87,30 @@ public:
         @param dy  vertical translation
         @return    SkMatrix with translation
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT Translate(SkScalar dx, SkScalar dy) {
+    [[nodiscard]] static SkMatrix Translate(SkScalar dx, SkScalar dy) {
         SkMatrix m;
         m.setTranslate(dx, dy);
         return m;
     }
-    static SkMatrix SK_WARN_UNUSED_RESULT Translate(SkVector t) { return Translate(t.x(), t.y()); }
-    static SkMatrix SK_WARN_UNUSED_RESULT Translate(SkIVector t) { return Translate(t.x(), t.y()); }
+    [[nodiscard]] static SkMatrix Translate(SkVector t) { return Translate(t.x(), t.y()); }
+    [[nodiscard]] static SkMatrix Translate(SkIVector t) { return Translate(t.x(), t.y()); }
 
     /** Sets SkMatrix to rotate by |deg| about a pivot point at (0, 0).
 
         @param deg  rotation angle in degrees (positive rotates clockwise)
         @return     SkMatrix with rotation
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT RotateDeg(SkScalar deg) {
+    [[nodiscard]] static SkMatrix RotateDeg(SkScalar deg) {
         SkMatrix m;
         m.setRotate(deg);
         return m;
     }
-    static SkMatrix SK_WARN_UNUSED_RESULT RotateDeg(SkScalar deg, SkPoint pt) {
+    [[nodiscard]] static SkMatrix RotateDeg(SkScalar deg, SkPoint pt) {
         SkMatrix m;
         m.setRotate(deg, pt.x(), pt.y());
         return m;
     }
-    static SkMatrix SK_WARN_UNUSED_RESULT RotateRad(SkScalar rad) {
+    [[nodiscard]] static SkMatrix RotateRad(SkScalar rad) {
         return RotateDeg(SkRadiansToDegrees(rad));
     }
 
@@ -120,7 +120,7 @@ public:
         @param ky  vertical skew factor
         @return    SkMatrix with skew
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT Skew(SkScalar kx, SkScalar ky) {
+    [[nodiscard]] static SkMatrix Skew(SkScalar kx, SkScalar ky) {
         SkMatrix m;
         m.setSkew(kx, ky);
         return m;
@@ -153,8 +153,8 @@ public:
         @param mode How to handle the mapping
         @return     SkMatrix mapping src to dst
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT RectToRect(const SkRect& src, const SkRect& dst,
-                                                     ScaleToFit mode = kFill_ScaleToFit) {
+    [[nodiscard]] static SkMatrix RectToRect(const SkRect& src, const SkRect& dst,
+                                             ScaleToFit mode = kFill_ScaleToFit) {
         return MakeRectToRect(src, dst, mode);
     }
 
@@ -175,9 +175,9 @@ public:
         @param pers2   perspective scale factor
         @return        SkMatrix constructed from parameters
     */
-    static SkMatrix SK_WARN_UNUSED_RESULT MakeAll(SkScalar scaleX, SkScalar skewX,  SkScalar transX,
-                                                  SkScalar skewY,  SkScalar scaleY, SkScalar transY,
-                                                  SkScalar pers0, SkScalar pers1, SkScalar pers2) {
+    [[nodiscard]] static SkMatrix MakeAll(SkScalar scaleX, SkScalar skewX,  SkScalar transX,
+                                          SkScalar skewY,  SkScalar scaleY, SkScalar transY,
+                                          SkScalar pers0, SkScalar pers1, SkScalar pers2) {
         SkMatrix m;
         m.setAll(scaleX, skewX, transX, skewY, scaleY, transY, pers0, pers1, pers2);
         return m;
@@ -1202,7 +1202,7 @@ public:
         @param inverse  storage for inverted SkMatrix; may be nullptr
         @return         true if SkMatrix can be inverted
     */
-    bool SK_WARN_UNUSED_RESULT invert(SkMatrix* inverse) const {
+    [[nodiscard]] bool invert(SkMatrix* inverse) const {
         // Allow the trivial case to be inlined.
         if (this->isIdentity()) {
             if (inverse) {
@@ -1237,7 +1237,7 @@ public:
         @param affine  storage for 3 by 2 affine matrix; may be nullptr
         @return        true if SkMatrix does not contain perspective
     */
-    bool SK_WARN_UNUSED_RESULT asAffine(SkScalar affine[6]) const;
+    [[nodiscard]] bool asAffine(SkScalar affine[6]) const;
 
     /** Sets SkMatrix to affine values, passed in column major order. Given affine,
         column, then row, as:
@@ -1705,7 +1705,7 @@ public:
         @param scaleFactors  storage for minimum and maximum scale factors
         @return              true if scale factors were computed correctly
     */
-    bool SK_WARN_UNUSED_RESULT getMinMaxScales(SkScalar scaleFactors[2]) const;
+    [[nodiscard]] bool getMinMaxScales(SkScalar scaleFactors[2]) const;
 
     /** Decomposes SkMatrix into scale components and whatever remains. Returns false if
         SkMatrix could not be decomposed.
@@ -1944,7 +1944,7 @@ private:
         return GetMapPtsProc(this->getType());
     }
 
-    bool SK_WARN_UNUSED_RESULT invertNonIdentity(SkMatrix* inverse) const;
+    [[nodiscard]] bool invertNonIdentity(SkMatrix* inverse) const;
 
     static bool Poly2Proc(const SkPoint[], SkMatrix*);
     static bool Poly3Proc(const SkPoint[], SkMatrix*);