@shopify/react-native-skia 0.1.192 → 0.1.193

package/android/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.4.1)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_GL -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_GL -DSK_GANESH -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
 
 set (PACKAGE_NAME "rnskia")
 set (SKIA_LIB "skia")

package/android/build.gradle

@@ -278,6 +278,7 @@ if (ENABLE_PREFAB) {
         into "${project.buildDir}/headers/rnskia/"
         includeEmptyDirs = false
         include "**/*.h"
+        duplicatesStrategy = 'include'
         eachFile {
             String path = it.path
 

package/android/cpp/jni/JniPlatformContext.cpp

@@ -101,7 +101,7 @@ sk_sp<SkImage> JniPlatformContext::takeScreenshotFromViewTag(size_t tag) {
   // Create pixmap from pixels and make a copy of it so that
   // the SkImage owns its own pixels
   SkPixmap pm(skInfo, pixels, bmi.stride);
-  auto skImage = SkImage::MakeRasterCopy(pm);
+  auto skImage = SkImages::RasterFromPixmapCopy(pm);
 
   // Unlock pixels
   AndroidBitmap_unlockPixels(env, bitmap);

package/cpp/api/JsiSkImage.h

@@ -14,7 +14,9 @@
 #include "SkBase64.h"
 #include "SkImage.h"
 #include "SkStream.h"
-#include <include/codec/SkCodec.h>
+#include "codec/SkEncodedImageFormat.h"
+#include "include/encode/SkJpegEncoder.h"
+#include "include/encode/SkPngEncoder.h"
 
 #pragma clang diagnostic pop
 
@@ -70,7 +72,15 @@ public:
     auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
 
     // Get data
-    auto data = getObject()->encodeToData(format, quality);
+    sk_sp<SkData> data;
+    if (format == SkEncodedImageFormat::kJPEG) {
+      SkJpegEncoder::Options options;
+      options.fQuality = quality;
+      data = SkJpegEncoder::Encode(nullptr, getObject().get(), options);
+    } else {
+      SkPngEncoder::Options options;
+      data = SkPngEncoder::Encode(nullptr, getObject().get(), options);
+    }
     auto arrayCtor =
         runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
     size_t size = data->size();
@@ -95,8 +105,19 @@ public:
                    : SkEncodedImageFormat::kPNG;
 
     auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
-
-    auto data = getObject()->encodeToData(format, quality);
+    auto image = getObject();
+    if (image->isTextureBacked()) {
+      image = image->makeNonTextureImage();
+    }
+    sk_sp<SkData> data;
+    if (format == SkEncodedImageFormat::kJPEG) {
+      SkJpegEncoder::Options options;
+      options.fQuality = quality;
+      data = SkJpegEncoder::Encode(nullptr, image.get(), options);
+    } else {
+      SkPngEncoder::Options options;
+      data = SkPngEncoder::Encode(nullptr, image.get(), options);
+    }
     auto len = SkBase64::Encode(data->bytes(), data->size(), nullptr);
     auto buffer = std::string(len, 0);
     SkBase64::Encode(data->bytes(), data->size(),

package/cpp/api/JsiSkImageFactory.h

@@ -18,7 +18,7 @@ class JsiSkImageFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(MakeImageFromEncoded) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
-    auto image = SkImage::MakeFromEncoded(data);
+    auto image = SkImages::DeferredFromEncodedData(data);
     if (image == nullptr) {
       return jsi::Value::null();
     }
@@ -30,7 +30,7 @@ public:
     auto imageInfo = JsiSkImageInfo::fromValue(runtime, arguments[0]);
     auto pixelData = JsiSkData::fromValue(runtime, arguments[1]);
     auto bytesPerRow = arguments[2].asNumber();
-    auto image = SkImage::MakeRasterData(*imageInfo, pixelData, bytesPerRow);
+    auto image = SkImages::RasterFromData(*imageInfo, pixelData, bytesPerRow);
     if (image == nullptr) {
       return jsi::Value::null();
     }

package/cpp/api/JsiSkPath.h

@@ -7,6 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkHostObjects.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
 #include "JsiSkRect.h"
@@ -20,13 +21,12 @@
 #include "SkPathEffect.h"
 #include "SkPathOps.h"
 #include "SkPathTypes.h"
+#include "SkPathUtils.h"
 #include "SkString.h"
 #include "SkStrokeRec.h"
 #include "SkTextUtils.h"
 #include "SkTrimPathEffect.h"
 
-#include "JsiSkMatrix.h"
-
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -284,8 +284,11 @@ public:
 
     auto jsiPrecision = opts.getProperty(runtime, "precision");
     auto precision = jsiPrecision.isUndefined() ? 1 : jsiPrecision.asNumber();
-    auto result = p.getFillPath(path, &path, nullptr, precision);
-    getObject()->swap(path);
+    auto result =
+        skpathutils::FillPathWithPaint(path, p, &path, nullptr, precision);
+    if (result) {
+      getObject()->swap(path);
+    }
     return result ? thisValue.getObject(runtime) : jsi::Value::null();
   }
 
@@ -320,8 +323,7 @@ public:
 
   JSI_HOST_FUNCTION(toSVGString) {
     SkPath path = *getObject();
-    SkString s;
-    SkParsePath::ToSVGString(path, &s);
+    auto s = SkParsePath::ToSVGString(path);
     return jsi::String::createFromUtf8(runtime, s.c_str());
   }
 

package/cpp/rnskia/dom/base/Declaration.h

@@ -24,17 +24,15 @@ public:
   void push(T el) { _elements.push(el); }
 
   // Clears and returns all elements
-  std::vector<T> popAll() { return popMultiple(_elements.size()); }
-
-  // Pops the number of items up to limit
-  std::vector<T> popMultiple(size_t limit) {
-    auto size = std::min(limit, _elements.size());
+  std::vector<T> popAll() {
+    auto size = _elements.size();
     std::vector<T> tmp;
     tmp.reserve(size);
     for (size_t i = 0; i < size; ++i) {
       tmp.push_back(_elements.top());
       _elements.pop();
     }
+    std::reverse(std::begin(tmp), std::end(tmp));
     return tmp;
   }
 
@@ -50,7 +48,7 @@ public:
   // Clears and returns through reducer function in reversed order
   T popAsOne(std::function<T(T inner, T outer)> composer) {
     auto tmp = popAll();
-    // std::reverse(std::begin(tmp), std::end(tmp));
+    std::reverse(std::begin(tmp), std::end(tmp));
     return std::accumulate(std::begin(tmp), std::end(tmp),
                            static_cast<T>(nullptr), [=](T inner, T outer) {
                              if (inner == nullptr) {
@@ -63,7 +61,7 @@ public:
   // Returns the size of the elements
   size_t size() { return _elements.size(); }
 
-protected:
+private:
   std::stack<T> _elements;
 };
 

package/cpp/rnskia/dom/nodes/JsiBlurMaskNode.h

@@ -10,6 +10,7 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
+#include "SkBlurTypes.h"
 #include "SkMaskFilter.h"
 
 #pragma clang diagnostic pop

package/cpp/rnskia/dom/nodes/JsiPathNode.h

@@ -108,8 +108,8 @@ protected:
           // _path is const so we can't mutate it directly, let's replace the
           // path like this:
           auto p = std::make_shared<SkPath>(*_path.get());
-          if (!strokePaint.getFillPath(*_path.get(), p.get(), nullptr,
-                                       precision)) {
+          if (!skpathutils::FillPathWithPaint(*_path.get(), strokePaint,
+                                              p.get(), nullptr, precision)) {
             _path = nullptr;
           } else {
             _path = std::const_pointer_cast<const SkPath>(p);

package/cpp/rnskia/dom/props/BoxShadowProps.h

@@ -5,6 +5,8 @@
 #include <memory>
 #include <utility>
 
+#include "SkBlurTypes.h"
+
 namespace RNSkia {
 
 class BoxShadowProps : public DerivedProp<SkPaint> {

package/cpp/skia/include/android/SkAndroidFrameworkUtils.h

@@ -27,7 +27,7 @@ class SkShader;
 class SkAndroidFrameworkUtils {
 public:
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
     /**
      *  clipWithStencil draws the current clip into a stencil buffer with reference value and mask
      *  set to 0x1. This function works only on a GPU canvas.
@@ -37,7 +37,7 @@ public:
      *  @return true on success or false if clip is empty or not a GPU canvas.
      */
     static bool clipWithStencil(SkCanvas* canvas);
-#endif //SK_SUPPORT_GPU
+#endif //defined(SK_GANESH)
 
     static void SafetyNetLog(const char*);
 
@@ -58,12 +58,6 @@ public:
      */
     static SkCanvas* getBaseWrappedCanvas(SkCanvas* canvas);
 
-    /**
-     * Skia will change the order in which local matrices concatenate. In order to not break Android
-     * apps targeting older API levels we offer this function to use the legacy concatenation order.
-     */
-    static void UseLegacyLocalMatrixConcatenation();
-
     /**
      *  If the shader represents a linear gradient ShaderAsALinearGradient
      *  returns true and if info is not null, ShaderAsALinearGradient populates

package/cpp/skia/include/android/SkImageAndroid.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkImageAndroid_DEFINED
+#define SkImageAndroid_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+
+class SkColorSpace;
+class GrDirectContext;
+class SkPixmap;
+struct AHardwareBuffer;
+
+namespace SkImages {
+
+/** (See Skia bug 7447)
+    Creates SkImage from Android hardware buffer.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param colorSpace      range of colors; may be nullptr
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(AHardwareBuffer* hardwareBuffer,
+                                                  SkAlphaType alphaType = kPremul_SkAlphaType);
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(
+        AHardwareBuffer* hardwareBuffer,
+        SkAlphaType alphaType,
+        sk_sp<SkColorSpace> colorSpace,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/** Creates SkImage from Android hardware buffer and uploads the data from the SkPixmap to it.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param context         GPU context
+    @param pixmap          SkPixmap that contains data to be uploaded to the AHardwareBuffer
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param surfaceOrigin   surface origin for resulting image
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromAHardwareBufferWithData(
+        GrDirectContext* context,
+        const SkPixmap& pixmap,
+        AHardwareBuffer* hardwareBuffer,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/**
+ *  Like SkImagePriv::SkMakeImageFromRasterBitmap, except this can be pinned using
+ *  skgpu::ganesh::PinAsTexture and CopyPixelMode is never.
+ */
+SK_API sk_sp<SkImage> PinnableRasterFromBitmap(const SkBitmap&);
+
+}  // namespace SkImages
+
+// TODO(kjlubick) remove this after Android has been ported.
+namespace sk_image_factory {
+inline sk_sp<SkImage> MakePinnableFromRasterBitmap(const SkBitmap& b) {
+    return SkImages::PinnableRasterFromBitmap(b);
+}
+}  // namespace sk_image_factory
+
+namespace skgpu::ganesh {
+/**
+ *  Will attempt to upload and lock the contents of the image as a texture, so that subsequent
+ *  draws to a gpu-target will come from that texture (and not by looking at the original image
+ *  src). In particular this is intended to use the texture even if the image's original content
+ *  changes subsequent to this call (i.e. the src is mutable!).
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  All successful calls must be balanced by an equal number of calls to UnpinTexture().
+ *
+ *  Once in this "pinned" state, the image has all of the same thread restrictions that exist
+ *  for a natively created gpu image (e.g. SkImage::MakeFromTexture)
+ *  - all drawing, pinning, unpinning must happen in the same thread as the GrContext.
+ *
+ *  @return true if the image was successfully uploaded and locked into a texture
+ */
+bool PinAsTexture(GrRecordingContext*, SkImage*);
+
+/**
+ *  The balancing call to a successful invocation of PinAsTexture. When a balanced
+ *  number of calls have been made, then the "pinned" texture is free to be purged, etc. This
+ *  also means that a subsequent "pin" call will look at the original content again, and if
+ *  its uniqueID/generationID has changed, then a newer texture will be uploaded/pinned.
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  The context passed to unpin must match the one passed to pin.
+ */
+void UnpinTexture(GrRecordingContext*, SkImage*);
+
+} // namespace skgpu::ganesh
+
+#endif

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

@@ -9,24 +9,27 @@
 #define SkAndroidCodec_DEFINED
 
 #include "include/codec/SkCodec.h"
-#include "include/core/SkAlphaType.h"
 #include "include/core/SkColorSpace.h"
-#include "include/core/SkColorType.h"
-#include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkEncodedInfo.h"
-#include "include/private/SkNoncopyable.h"
+#include "include/private/base/SkNoncopyable.h"
 #include "modules/skcms/skcms.h"
 
+// TODO(kjlubick, bungeman) Replace these includes with forward declares
+#include "include/codec/SkEncodedImageFormat.h" // IWYU pragma: keep
+#include "include/core/SkAlphaType.h" // IWYU pragma: keep
+#include "include/core/SkColorType.h" // IWYU pragma: keep
+
 #include <cstddef>
 #include <memory>
 
 class SkData;
 class SkPngChunkReader;
 class SkStream;
+struct SkGainmapInfo;
 struct SkIRect;
 
 /**
@@ -118,10 +121,8 @@ public:
     /**
      *  @param outputColorType Color type that the client will decode to.
      *  @param prefColorSpace  Preferred color space to decode to.
-     *                         This may not return |prefColorSpace| for a couple reasons.
-     *                         (1) Android Principles: 565 must be sRGB, F16 must be
-     *                             linear sRGB, transfer function must be parametric.
-     *                         (2) Codec Limitations: F16 requires a linear color space.
+     *                         This may not return |prefColorSpace| for
+     *                         specific color types.
      *
      *  Returns the appropriate color space to decode to.
      */
@@ -262,6 +263,23 @@ public:
 
     SkCodec* codec() const { return fCodec.get(); }
 
+    /**
+     *  Retrieve the gainmap for an image.
+     *
+     *  @param outInfo                On success, this is populated with the parameters for
+     *                                rendering this gainmap. This parameter must be non-nullptr.
+     *
+     *  @param outGainmapImageStream  On success, this is populated with a stream from which the
+     *                                gainmap image may be decoded. This parameter is optional, and
+     *                                may be set to nullptr.
+     *
+     *  @return                       If this has a gainmap image and that gainmap image was
+     *                                successfully extracted then return true. Otherwise return
+     *                                false.
+     */
+    bool getAndroidGainmap(SkGainmapInfo* outInfo,
+                           std::unique_ptr<SkStream>* outGainmapImageStream);
+
 protected:
     SkAndroidCodec(SkCodec*);
 

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

@@ -8,10 +8,7 @@
 #ifndef SkCodec_DEFINED
 #define SkCodec_DEFINED
 
-#include "include/codec/SkCodecAnimation.h"
 #include "include/codec/SkEncodedOrigin.h"
-#include "include/core/SkAlphaType.h"
-#include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkPixmap.h"
 #include "include/core/SkRect.h"
@@ -20,21 +17,30 @@
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAPixmaps.h"
 #include "include/private/SkEncodedInfo.h"
-#include "include/private/SkNoncopyable.h"
+#include "include/private/base/SkNoncopyable.h"
 #include "modules/skcms/skcms.h"
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <tuple>
 #include <vector>
 
-class SkAndroidCodec;
 class SkData;
 class SkFrameHolder;
 class SkImage;
 class SkPngChunkReader;
 class SkSampler;
 class SkStream;
+struct SkGainmapInfo;
+enum SkAlphaType : int;
+enum class SkEncodedImageFormat;
+
+namespace SkCodecAnimation {
+enum class Blend;
+enum class DisposalMethod;
+}
+
 
 namespace DM {
 class CodecSrc;
@@ -767,6 +773,8 @@ protected:
         return fSrcXformFormat;
     }
 
+    virtual bool onGetGainmapInfo(SkGainmapInfo*, std::unique_ptr<SkStream>*) { return false; }
+
     virtual SkISize onGetScaledDimensions(float /*desiredScale*/) const {
         // By default, scaling is not supported.
         return this->dimensions();
@@ -887,8 +895,8 @@ private:
     const SkEncodedInfo                fEncodedInfo;
     XformFormat                        fSrcXformFormat;
     std::unique_ptr<SkStream>          fStream;
-    bool                               fNeedsRewind;
-    const SkEncodedOrigin              fOrigin;
+    bool fNeedsRewind = false;
+    const SkEncodedOrigin fOrigin;
 
     SkImageInfo                        fDstInfo;
     Options                            fOptions;
@@ -904,13 +912,13 @@ private:
     skcms_AlphaFormat                  fDstXformAlphaFormat;
 
     // Only meaningful during scanline decodes.
-    int                                fCurrScanline;
+    int fCurrScanline = -1;
 
-    bool                               fStartedIncrementalDecode;
+    bool fStartedIncrementalDecode = false;
 
     // Allows SkAndroidCodec to call handleFrameIndex (potentially decoding a prior frame and
-    // clearing to transparent) without SkCodec calling it, too.
-    bool                               fAndroidCodecHandlesFrameIndex;
+    // clearing to transparent) without SkCodec itself calling it, too.
+    bool fUsingCallbackForHandleFrameIndex = false;
 
     bool initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha, bool srcIsOpaque);
 
@@ -934,17 +942,23 @@ private:
         return nullptr;
     }
 
+    // Callback for decoding a prior frame. The `Options::fFrameIndex` is ignored,
+    // being replaced by frameIndex. This allows opts to actually be a subclass of
+    // SkCodec::Options which SkCodec itself does not know how to copy or modify,
+    // but just passes through to the caller (where it can be reinterpret_cast'd).
+    using GetPixelsCallback = std::function<Result(const SkImageInfo&, void* pixels,
+                                                   size_t rowBytes, const Options& opts,
+                                                   int frameIndex)>;
+
     /**
      *  Check for a valid Options.fFrameIndex, and decode prior frames if necessary.
      *
-     *  If androidCodec is not null, that means this SkCodec is owned by an SkAndroidCodec. In that
-     *  case, the Options will be treated as an AndroidOptions, and SkAndroidCodec will be used to
-     *  decode a prior frame, if a prior frame is needed. When such an owned SkCodec calls
-     *  handleFrameIndex, it will immediately return kSuccess, since SkAndroidCodec already handled
-     *  it.
+     * If GetPixelsCallback is not null, it will be used to decode a prior frame instead
+     * of using this SkCodec directly. It may also be used recursively, if that in turn
+     * depends on a prior frame. This is used by SkAndroidCodec.
      */
     Result handleFrameIndex(const SkImageInfo&, void* pixels, size_t rowBytes, const Options&,
-            SkAndroidCodec* androidCodec = nullptr);
+                            GetPixelsCallback = nullptr);
 
     // Methods for scanline decoding.
     virtual Result onStartScanlineDecode(const SkImageInfo& /*dstInfo*/,

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncodedImageFormat_DEFINED
+#define SkEncodedImageFormat_DEFINED
+
+#include <stdint.h>
+
+/**
+ *  Enum describing format of encoded data.
+ */
+enum class SkEncodedImageFormat {
+#ifdef SK_BUILD_FOR_GOOGLE3
+    kUnknown,
+#endif
+    kBMP,
+    kGIF,
+    kICO,
+    kJPEG,
+    kPNG,
+    kWBMP,
+    kWEBP,
+    kPKM,
+    kKTX,
+    kASTC,
+    kDNG,
+    kHEIF,
+    kAVIF,
+    kJPEGXL,
+};
+
+#endif  // SkEncodedImageFormat_DEFINED

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPixmapUtils_DEFINED
+#define SkPixmapUtils_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkImageInfo.h"
+#include "include/private/base/SkAPI.h"
+
+class SkPixmap;
+
+namespace SkPixmapUtils {
+/**
+ *  Copy the pixels in src into dst, applying the orientation transformations specified
+ *  by origin. If the inputs are invalid, this returns false and no copy is made.
+ */
+SK_API bool Orient(const SkPixmap& dst, const SkPixmap& src, SkEncodedOrigin origin);
+
+/**
+ *  Return a copy of the provided ImageInfo with the width and height swapped.
+ */
+SK_API SkImageInfo SwapWidthHeight(const SkImageInfo& info);
+
+}  // namespace SkPixmapUtils
+
+#endif // SkPixmapUtils_DEFINED