@shopify/react-native-skia 0.1.192 → 0.1.193

package/cpp/skia/include/ports/SkFontMgr_indirect.h

@@ -13,9 +13,9 @@
 #include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 #include "include/ports/SkRemotableFontMgr.h"
-#include "include/private/SkMutex.h"
-#include "include/private/SkOnce.h"
-#include "include/private/SkTArray.h"
+#include "include/private/base/SkMutex.h"
+#include "include/private/base/SkOnce.h"
+#include "include/private/base/SkTArray.h"
 
 class SkData;
 class SkFontStyle;
@@ -34,18 +34,18 @@ public:
 protected:
     int onCountFamilies() const override;
     void onGetFamilyName(int index, SkString* familyName) const override;
-    SkFontStyleSet* onCreateStyleSet(int index) const override;
+    sk_sp<SkFontStyleSet> onCreateStyleSet(int index) const override;
 
-    SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
+    sk_sp<SkFontStyleSet> onMatchFamily(const char familyName[]) const override;
 
-    SkTypeface* onMatchFamilyStyle(const char familyName[],
-                                   const SkFontStyle& fontStyle) const override;
+    sk_sp<SkTypeface> onMatchFamilyStyle(const char familyName[],
+                                         const SkFontStyle& fontStyle) const override;
 
-    SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
-                                            const SkFontStyle&,
-                                            const char* bcp47[],
-                                            int bcp47Count,
-                                            SkUnichar character) const override;
+    sk_sp<SkTypeface> onMatchFamilyStyleCharacter(const char familyName[],
+                                                  const SkFontStyle&,
+                                                  const char* bcp47[],
+                                                  int bcp47Count,
+                                                  SkUnichar character) const override;
 
     sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>, int ttcIndex) const override;
     sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset> stream,
@@ -55,7 +55,7 @@ protected:
     sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const override;
 
 private:
-    SkTypeface* createTypefaceFromFontId(const SkFontIdentity& fontId) const;
+    sk_sp<SkTypeface> createTypefaceFromFontId(const SkFontIdentity& fontId) const;
 
     sk_sp<SkFontMgr> fImpl;
     sk_sp<SkRemotableFontMgr> fProxy;
@@ -93,7 +93,7 @@ private:
      *  typefaces with that data id. By storing the index next to the typeface,
      *  this data cache also acts as a typeface cache.
      */
-    mutable SkTArray<DataEntry> fDataCache;
+    mutable skia_private::TArray<DataEntry> fDataCache;
     mutable SkMutex fDataCacheMutex;
 
     friend class SkStyleSet_Indirect;

package/cpp/skia/include/ports/SkRemotableFontMgr.h

@@ -11,7 +11,7 @@
 #include "include/core/SkFontStyle.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkTemplates.h"
+#include "include/private/base/SkTemplates.h"
 
 class SkDataTable;
 class SkStreamAsset;
@@ -48,7 +48,7 @@ private:
     friend SkRemotableFontIdentitySet* sk_remotable_font_identity_set_new();
 
     int fCount;
-    SkAutoTArray<SkFontIdentity> fData;
+    skia_private::AutoTArray<SkFontIdentity> fData;
 
     using INHERITED = SkRefCnt;
 };

package/cpp/skia/include/ports/SkTypeface_win.h

@@ -8,6 +8,7 @@
 #ifndef SkTypeface_win_DEFINED
 #define SkTypeface_win_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 
@@ -26,7 +27,7 @@ typedef LOGFONTA LOGFONT;
  *  corresponding typeface for the specified logfont. The caller is responsible
  *  for calling unref() when it is finished.
  */
-SK_API SkTypeface* SkCreateTypefaceFromLOGFONT(const LOGFONT&);
+SK_API sk_sp<SkTypeface> SkCreateTypefaceFromLOGFONT(const LOGFONT&);
 
 /**
  *  Copy the LOGFONT associated with this typeface into the lf parameter. Note

package/cpp/skia/include/private/SkChecksum.h

@@ -10,17 +10,22 @@
 
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkNoncopyable.h"
 #include "include/private/SkOpts_spi.h"
-#include "include/private/SkTLogic.h"
+#include "include/private/base/SkTLogic.h"
 
 #include <string>
 #include <string_view>
+#include <type_traits>
 
-class SkChecksum : SkNoncopyable {
+class SkChecksum {
 public:
+    SkChecksum() = default;
+    // Make noncopyable
+    SkChecksum(const SkChecksum&) = delete;
+    SkChecksum& operator=(const SkChecksum&) = delete;
+
     /**
-     * uint32_t -> uint32_t hash, useful for when you're about to trucate this hash but you
+     * uint32_t -> uint32_t hash, useful for when you're about to truncate this hash but you
      * suspect its low bits aren't well mixed.
      *
      * This is the Murmur3 finalizer.
@@ -35,7 +40,7 @@ public:
     }
 
     /**
-     * uint32_t -> uint32_t hash, useful for when you're about to trucate this hash but you
+     * uint32_t -> uint32_t hash, useful for when you're about to truncate this hash but you
      * suspect its low bits aren't well mixed.
      *
      *  This version is 2-lines cheaper than Mix, but seems to be sufficient for the font cache.
@@ -52,12 +57,14 @@ public:
 // It should be both reasonably fast and high quality.
 struct SkGoodHash {
     template <typename K>
-    std::enable_if_t<sizeof(K) == 4, uint32_t> operator()(const K& k) const {
+    std::enable_if_t<std::has_unique_object_representations<K>::value && sizeof(K) == 4, uint32_t>
+    operator()(const K& k) const {
         return SkChecksum::Mix(*(const uint32_t*)&k);
     }
 
     template <typename K>
-    std::enable_if_t<sizeof(K) != 4, uint32_t> operator()(const K& k) const {
+    std::enable_if_t<std::has_unique_object_representations<K>::value && sizeof(K) != 4, uint32_t>
+    operator()(const K& k) const {
         return SkOpts::hash_fn(&k, sizeof(K), 0);
     }
 
@@ -74,4 +81,22 @@ struct SkGoodHash {
     }
 };
 
+// The default hashing behavior in SkGoodHash requires the type to have a unique object
+// representation (i.e. all bits in contribute to its identity so can be hashed directly). This is
+// false when a struct has padding for alignment (which can be avoided by using
+// SK_BEGIN|END_REQUIRE_DENSE) or if the struct has floating point members since there are multiple
+// bit representations for NaN.
+//
+// Often Skia code has externally removed the possibility of NaN so the bit representation of a
+// non-NaN float will still hash correctly. SkForceDirectHash<K> produces the same as SkGoodHash
+// for K's that do not satisfy std::has_unique_object_representation. It should be used sparingly
+// and it's use may highlight design issues with the key's data that might warrant an explicitly
+// implemented hash function.
+template <typename K>
+struct SkForceDirectHash {
+    uint32_t operator()(const K& k) const {
+        return SkOpts::hash_fn(&k, sizeof(K), 0);
+    }
+};
+
 #endif

package/cpp/skia/include/private/SkColorData.h

@@ -10,8 +10,7 @@
 
 #include "include/core/SkColor.h"
 #include "include/core/SkColorPriv.h"
-#include "include/private/SkTo.h"
-#include "include/private/SkVx.h"
+#include "include/private/base/SkTo.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Convert a 16bit pixel to a 32bit pixel
@@ -374,30 +373,6 @@ static inline SkPMColor SkPixel4444ToPixel32(U16CPU c) {
     return d | (d << 4);
 }
 
-static inline skvx::float4 swizzle_rb(const skvx::float4& x) {
-    return skvx::shuffle<2, 1, 0, 3>(x);
-}
-
-static inline skvx::float4 swizzle_rb_if_bgra(const skvx::float4& x) {
-#ifdef SK_PMCOLOR_IS_BGRA
-    return swizzle_rb(x);
-#else
-    return x;
-#endif
-}
-
-static inline skvx::float4 Sk4f_fromL32(uint32_t px) {
-    return skvx::cast<float>(skvx::byte4::Load(&px)) * (1 / 255.0f);
-}
-
-static inline uint32_t Sk4f_toL32(const skvx::float4& px) {
-    uint32_t l32;
-    // For the expected positive color values, the +0.5 before the pin and cast effectively rounds
-    // to the nearest int without having to call round() or lrint().
-    skvx::cast<uint8_t>(pin(px * 255.f + 0.5f, skvx::float4(0.f), skvx::float4(255.f))).store(&l32);
-    return l32;
-}
-
 using SkPMColor4f = SkRGBA4f<kPremul_SkAlphaType>;
 
 constexpr SkPMColor4f SK_PMColor4fTRANSPARENT = { 0, 0, 0, 0 };

package/cpp/skia/include/private/SkGainmapInfo.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkGainmapInfo_DEFINED
+#define SkGainmapInfo_DEFINED
+
+#include "include/core/SkColor.h"
+
+/**
+ *  Gainmap rendering parameters. Suppose our display has HDR to SDR ratio of H and we wish to
+ *  display an image with gainmap on this display. Let B be the pixel value from the base image
+ *  in a color space that has the primaries of the base image and a linear transfer function. Let
+ *  G be the pixel value from the gainmap. Let D be the output pixel in the same color space as B.
+ *  The value of D is computed as follows:
+ *
+ *  First, let W be a weight parameter determing how much the gainmap will be applied.
+ *    W = clamp((log(H)                - log(fDisplayRatioSdr)) /
+ *              (log(fDisplayRatioHdr) - log(fDisplayRatioSdr), 0, 1)
+ *
+ *  Next, let L be the gainmap value in log space. We compute this from the value G that was
+ *  sampled from the texture as follows:
+ *    L = mix(log(fGainmapRatioMin), log(fGainmapRatioMax), pow(G, fGainmapGamma))
+ *
+ *  Finally, apply the gainmap to compute D, the displayed pixel. If the base image is SDR then
+ *  compute:
+ *    D = (B + fEpsilonSdr) * exp(L * W) - fEpsilonHdr
+ *  If the base image is HDR then compute:
+ *    D = (B + fEpsilonHdr) * exp(L * (W - 1)) - fEpsilonSdr
+ *
+ *  In the above math, log() is a natural logarithm and exp() is natural exponentiation. Note,
+ *  however, that the base used for the log() and exp() functions does not affect the results of
+ *  the computation (it cancels out, as long as the same base is used throughout).
+ */
+struct SkGainmapInfo {
+    /**
+     *  Parameters for converting the gainmap from its image encoding to log space. These are
+     *  specified per color channel. The alpha value is unused.
+     */
+    SkColor4f fGainmapRatioMin = {1.f, 1.f, 1.f, 1.0};
+    SkColor4f fGainmapRatioMax = {2.f, 2.f, 2.f, 1.0};
+    SkColor4f fGainmapGamma = {1.f, 1.f, 1.f, 1.f};
+
+    /**
+     *  Parameters sometimes used in gainmap computation to avoid numerical instability.
+     */
+    SkColor4f fEpsilonSdr = {0.f, 0.f, 0.f, 1.0};
+    SkColor4f fEpsilonHdr = {0.f, 0.f, 0.f, 1.0};
+
+    /**
+     *  If the output display's HDR to SDR ratio is less or equal than fDisplayRatioSdr then the SDR
+     *  rendition is displayed. If the output display's HDR to SDR ratio is greater or equal than
+     *  fDisplayRatioHdr then the HDR rendition is displayed. If the output display's HDR to SDR
+     *  ratio is between these values then an interpolation between the two is displayed using the
+     *  math above.
+     */
+    float fDisplayRatioSdr = 1.f;
+    float fDisplayRatioHdr = 2.f;
+
+    /**
+     *  Whether the base image is the SDR image or the HDR image.
+     */
+    enum class BaseImageType {
+        kSDR,
+        kHDR,
+    };
+    BaseImageType fBaseImageType = BaseImageType::kSDR;
+
+    inline bool operator==(const SkGainmapInfo& other) {
+        return fGainmapRatioMin == other.fGainmapRatioMin &&
+               fGainmapRatioMax == other.fGainmapRatioMax && fGainmapGamma == other.fGainmapGamma &&
+               fEpsilonSdr == other.fEpsilonSdr && fEpsilonHdr == other.fEpsilonHdr &&
+               fDisplayRatioSdr == other.fDisplayRatioSdr &&
+               fDisplayRatioHdr == other.fDisplayRatioHdr && fBaseImageType == other.fBaseImageType;
+    }
+    inline bool operator!=(const SkGainmapInfo& other) { return !(*this == other); }
+
+    // TODO(ccameron): Remove these parameters once we are certain they are not used in Android.
+    enum class Type {
+        kUnknown,
+        kMultiPicture,
+        kJpegR_Linear,
+        kJpegR_HLG,
+        kJpegR_PQ,
+        kHDRGM,
+    };
+    SkColor4f fLogRatioMin = {0.f, 0.f, 0.f, 1.0};
+    SkColor4f fLogRatioMax = {1.f, 1.f, 1.f, 1.0};
+    float fHdrRatioMin = 1.f;
+    float fHdrRatioMax = 50.f;
+    Type fType = Type::kUnknown;
+};
+
+#endif

package/cpp/skia/include/private/SkGainmapShader.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkGainmapShader_DEFINED
+#define SkGainmapShader_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkColorSpace;
+class SkShader;
+class SkImage;
+struct SkGainmapInfo;
+struct SkRect;
+struct SkSamplingOptions;
+
+/**
+ *  A gainmap shader will apply a gainmap to an base image using the math described alongside the
+ *  definition of SkGainmapInfo.
+ */
+class SK_API SkGainmapShader {
+public:
+    /**
+     *  Make a gainmap shader.
+     *
+     *  When sampling the base image baseImage, the rectangle baseRect will be sampled to map to
+     *  the rectangle dstRect. Sampling will be done according to baseSamplingOptions.
+     *
+     *  When sampling the gainmap image gainmapImage, the rectangle gainmapRect will be sampled to
+     *  map to the rectangle dstRect. Sampling will be done according to gainmapSamplingOptions.
+     *
+     *  The gainmap will be applied according to the HDR to SDR ratio specified in dstHdrRatio.
+     *
+     *  This shader must know the color space of the canvas that it will be rendered to. This color
+     *  space must be specified in dstColorSpace.
+     *  TODO(ccameron): Remove the need for dstColorSpace.
+     */
+    static sk_sp<SkShader> Make(const sk_sp<const SkImage>& baseImage,
+                                const SkRect& baseRect,
+                                const SkSamplingOptions& baseSamplingOptions,
+                                const sk_sp<const SkImage>& gainmapImage,
+                                const SkRect& gainmapRect,
+                                const SkSamplingOptions& gainmapSamplingOptions,
+                                const SkGainmapInfo& gainmapInfo,
+                                const SkRect& dstRect,
+                                float dstHdrRatio,
+                                sk_sp<SkColorSpace> dstColorSpace);
+};
+
+#endif

package/cpp/skia/include/private/SkIDChangeListener.h

@@ -9,8 +9,9 @@
 #define SkIDChangeListener_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkMutex.h"
-#include "include/private/SkTDArray.h"
+#include "include/private/base/SkMutex.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/base/SkThreadAnnotations.h"
 
 #include <atomic>
 
@@ -65,7 +66,7 @@ public:
 
     private:
         mutable SkMutex fMutex;
-        SkTDArray<SkIDChangeListener*> fListeners SK_GUARDED_BY(fMutex);  // pointers are reffed
+        skia_private::STArray<1, sk_sp<SkIDChangeListener>> fListeners SK_GUARDED_BY(fMutex);
     };
 
 private:

package/cpp/skia/include/private/SkJpegGainmapEncoder.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegGainmapEncoder_DEFINED
+#define SkJpegGainmapEncoder_DEFINED
+
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+struct SkGainmapInfo;
+
+class SK_API SkJpegGainmapEncoder {
+public:
+    /**
+     *  Encode a JpegR image to |dst|.
+     *
+     *  The base image is specified by |base|, and |baseOptions| controls the encoding behavior for
+     *  the base image.
+     *
+     *  The gainmap image is specified by |gainmap|, and |gainmapOptions| controls the encoding
+     *  behavior for the gainmap image.
+     *
+     *  The rendering behavior of the gainmap image is provided in |gainmapInfo|. Not all gainmap
+     *  based images are compatible with JpegR. If the image is not compatible with JpegR, then
+     *  convert the gainmap to a format that is capable with JpegR. This conversion may result in
+     *  less precise quantization of the gainmap image.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool EncodeJpegR(SkWStream* dst,
+                            const SkPixmap& base,
+                            const SkJpegEncoder::Options& baseOptions,
+                            const SkPixmap& gainmap,
+                            const SkJpegEncoder::Options& gainmapOptions,
+                            const SkGainmapInfo& gainmapInfo);
+
+    /**
+     *  Encode an HDRGM image to |dst|.
+     *
+     *  The base image is specified by |base|, and |baseOptions| controls the encoding behavior for
+     *  the base image.
+     *
+     *  The gainmap image is specified by |gainmap|, and |gainmapOptions| controls the encoding
+     *  behavior for the gainmap image.
+     *
+     *  The rendering behavior of the gainmap image is provided in |gainmapInfo|.
+     *
+     *  If |baseOptions| or |gainmapOptions| specify XMP metadata, then that metadata will be
+     *  overwritten.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool EncodeHDRGM(SkWStream* dst,
+                            const SkPixmap& base,
+                            const SkJpegEncoder::Options& baseOptions,
+                            const SkPixmap& gainmap,
+                            const SkJpegEncoder::Options& gainmapOptions,
+                            const SkGainmapInfo& gainmapInfo);
+
+    /**
+     *  Write a Multi Picture Format containing the |imageCount| images specified by |images|.
+     */
+    static bool MakeMPF(SkWStream* dst, const SkData** images, size_t imageCount);
+};
+
+#endif

package/cpp/skia/include/private/SkJpegMetadataDecoder.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegMetadataDecoder_DEFINED
+#define SkJpegMetadataDecoder_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+#include <vector>
+
+struct SkGainmapInfo;
+
+/**
+ * An interface that can be used to extract metadata from an encoded JPEG file.
+ * TODO(https://crbug.com/1404000): Add interface for ICC profile and EXIF extraction.
+ */
+class SK_API SkJpegMetadataDecoder {
+public:
+    SkJpegMetadataDecoder() {}
+    virtual ~SkJpegMetadataDecoder() {}
+
+    SkJpegMetadataDecoder(const SkJpegMetadataDecoder&) = delete;
+    SkJpegMetadataDecoder& operator=(const SkJpegMetadataDecoder&) = delete;
+
+    /**
+     * A segment from a JPEG file. This is usually populated from a jpeg_marker_struct.
+     */
+    struct SK_API Segment {
+        Segment(uint8_t marker, sk_sp<SkData> data) : fMarker(marker), fData(std::move(data)) {}
+
+        // The segment's marker.
+        uint8_t fMarker = 0;
+
+        // The segment's parameters (not including the marker and parameter length).
+        sk_sp<SkData> fData;
+    };
+
+    /**
+     * Create metadata for the specified segments from a JPEG file's header (defined as all segments
+     * before the first StartOfScan). This may return nullptr.
+     */
+    static std::unique_ptr<SkJpegMetadataDecoder> Make(std::vector<Segment> headerSegments);
+
+    /**
+     * Given a JPEG encoded image |baseImageData|, return in |outGainmapImageData| the JPEG encoded
+     * gainmap image and return in |outGainmapInfo| its gainmap rendering parameters. Return true if
+     * both output variables were successfully populated, otherwise return false.
+     */
+    virtual bool findGainmapImage(sk_sp<SkData> baseImageData,
+                                  sk_sp<SkData>& outGainmapImagedata,
+                                  SkGainmapInfo& outGainmapInfo) = 0;
+};
+
+#endif

package/cpp/skia/include/private/SkOpts_spi.h

@@ -8,7 +8,9 @@
 #ifndef SkOpts_spi_DEFINED
 #define SkOpts_spi_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
 
 // These are exposed as SK_SPI (e.g. SkParagraph), the rest of SkOpts is
 // declared in src/core