@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -62,10 +62,43 @@ public:
     struct Interpolation {
         enum class InPremul : bool { kNo = false, kYes = true };
 
-        InPremul fInPremul = InPremul::kNo;
+        enum class ColorSpace : uint8_t {
+            // Default Skia behavior: interpolate in the color space of the destination surface
+            kDestination,
+
+            // https://www.w3.org/TR/css-color-4/#interpolation-space
+            kSRGBLinear,
+            kLab,
+            kOKLab,
+            kLCH,
+            kOKLCH,
+            kSRGB,
+            kHSL,
+            kHWB,
+
+            kLastColorSpace = kHWB,
+        };
+        static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1;
+
+        enum class HueMethod : uint8_t {
+            // https://www.w3.org/TR/css-color-4/#hue-interpolation
+            kShorter,
+            kLonger,
+            kIncreasing,
+            kDecreasing,
+
+            kLastHueMethod = kDecreasing,
+        };
+        static constexpr int kHueMethodCount = static_cast<int>(HueMethod::kLastHueMethod) + 1;
+
+        InPremul   fInPremul = InPremul::kNo;
+        ColorSpace fColorSpace = ColorSpace::kDestination;
+        HueMethod  fHueMethod  = HueMethod::kShorter;  // Only relevant for LCH, OKLCH, HSL, or HWB
 
         static Interpolation FromFlags(uint32_t flags) {
-            return {flags & kInterpolateColorsInPremul_Flag ? InPremul::kYes : InPremul::kNo};
+            return {flags & kInterpolateColorsInPremul_Flag ? InPremul::kYes : InPremul::kNo,
+                    ColorSpace::kDestination,
+                    HueMethod::kShorter};
         }
     };
 
@@ -76,8 +109,11 @@ public:
         @param  pos     May be NULL. array[count] of SkScalars, or NULL, of the relative position of
                         each corresponding color in the colors array. If this is NULL,
                         the the colors are distributed evenly between the start and end point.
-                        If this is not null, the values must begin with 0, end with 1.0, and
-                        intermediate values must be strictly increasing.
+                        If this is not null, the values must lie between 0.0 and 1.0, and be
+                        strictly increasing. If the first value is not 0.0, then an additional
+                        color stop is added at position 0.0, with the same color as colors[0].
+                        If the the last value is not 1.0, then an additional color stop is added
+                        at position 1.0, with the same color as colors[count - 1].
         @param  count   Must be >=2. The number of colors (and pos if not NULL) entries.
         @param  mode    The tiling mode
 
@@ -95,8 +131,11 @@ public:
         @param  pos     May be NULL. array[count] of SkScalars, or NULL, of the relative position of
                         each corresponding color in the colors array. If this is NULL,
                         the the colors are distributed evenly between the start and end point.
-                        If this is not null, the values must begin with 0, end with 1.0, and
-                        intermediate values must be strictly increasing.
+                        If this is not null, the values must lie between 0.0 and 1.0, and be
+                        strictly increasing. If the first value is not 0.0, then an additional
+                        color stop is added at position 0.0, with the same color as colors[0].
+                        If the the last value is not 1.0, then an additional color stop is added
+                        at position 1.0, with the same color as colors[count - 1].
         @param  count   Must be >=2. The number of colors (and pos if not NULL) entries.
         @param  mode    The tiling mode
 
@@ -123,8 +162,11 @@ public:
         @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
                         each corresponding color in the colors array. If this is NULL,
                         the the colors are distributed evenly between the center and edge of the circle.
-                        If this is not null, the values must begin with 0, end with 1.0, and
-                        intermediate values must be strictly increasing.
+                        If this is not null, the values must lie between 0.0 and 1.0, and be
+                        strictly increasing. If the first value is not 0.0, then an additional
+                        color stop is added at position 0.0, with the same color as colors[0].
+                        If the the last value is not 1.0, then an additional color stop is added
+                        at position 1.0, with the same color as colors[count - 1].
         @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
         @param  mode    The tiling mode
     */
@@ -141,8 +183,11 @@ public:
         @param  pos     May be NULL. The array[count] of SkScalars, or NULL, of the relative position of
                         each corresponding color in the colors array. If this is NULL,
                         the the colors are distributed evenly between the center and edge of the circle.
-                        If this is not null, the values must begin with 0, end with 1.0, and
-                        intermediate values must be strictly increasing.
+                        If this is not null, the values must lie between 0.0 and 1.0, and be
+                        strictly increasing. If the first value is not 0.0, then an additional
+                        color stop is added at position 0.0, with the same color as colors[0].
+                        If the the last value is not 1.0, then an additional color stop is added
+                        at position 1.0, with the same color as colors[count - 1].
         @param  count   Must be >= 2. The number of colors (and pos if not NULL) entries
         @param  mode    The tiling mode
     */
@@ -214,8 +259,11 @@ public:
         @param  pos        May be NULL. The array[count] of SkScalars, or NULL, of the relative
                            position of each corresponding color in the colors array. If this is
                            NULL, then the colors are distributed evenly within the angular range.
-                           If this is not null, the values must begin with 0, end with 1.0, and
-                           intermediate values must be strictly increasing.
+                           If this is not null, the values must lie between 0.0 and 1.0, and be
+                           strictly increasing. If the first value is not 0.0, then an additional
+                           color stop is added at position 0.0, with the same color as colors[0].
+                           If the the last value is not 1.0, then an additional color stop is added
+                           at position 1.0, with the same color as colors[count - 1].
         @param  count      Must be >= 2. The number of colors (and pos if not NULL) entries
         @param  mode       Tiling mode: controls drawing outside of the gradient angular range.
         @param  startAngle Start of the angular range, corresponding to pos == 0.
@@ -250,8 +298,11 @@ public:
         @param  pos        May be NULL. The array[count] of SkScalars, or NULL, of the relative
                            position of each corresponding color in the colors array. If this is
                            NULL, then the colors are distributed evenly within the angular range.
-                           If this is not null, the values must begin with 0, end with 1.0, and
-                           intermediate values must be strictly increasing.
+                           If this is not null, the values must lie between 0.0 and 1.0, and be
+                           strictly increasing. If the first value is not 0.0, then an additional
+                           color stop is added at position 0.0, with the same color as colors[0].
+                           If the the last value is not 1.0, then an additional color stop is added
+                           at position 1.0, with the same color as colors[count - 1].
         @param  count      Must be >= 2. The number of colors (and pos if not NULL) entries
         @param  mode       Tiling mode: controls drawing outside of the gradient angular range.
         @param  startAngle Start of the angular range, corresponding to pos == 0.

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

@@ -310,17 +310,6 @@ public:
     static sk_sp<SkImageFilter> Offset(SkScalar dx, SkScalar dy, sk_sp<SkImageFilter> input,
                                        const CropRect& cropRect = {});
 
-    /**
-     *  Create a filter that fills the output with the given paint.
-     *  @param paint    The paint to fill
-     *  @param cropRect Optional rectangle that will be filled. If null, the source bitmap's bounds
-     *                  are filled even though the source bitmap itself is not used.
-     *
-     * DEPRECATED: Use Shader() instead, since many features of SkPaint are ignored when filling
-     *             the target output, and paint color/alpha can be emulated with SkShaders::Color().
-     */
-    static sk_sp<SkImageFilter> Paint(const SkPaint& paint, const CropRect& cropRect = {});
-
     /**
      *  Create a filter that produces the SkPicture as its output, drawn into targetRect. Note that
      *  the targetRect is not the same as the SkIRect cropRect that many filters accept. Returns

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

@@ -16,8 +16,10 @@
 #include "include/core/SkShader.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
-#include "include/private/SkOnce.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkSLSampleUsage.h"
+#include "include/private/base/SkOnce.h"
+#include "include/private/base/SkTemplates.h"
 
 #include <string>
 #include <optional>
@@ -34,6 +36,7 @@ class SkRuntimeImageFilter;
 
 namespace SkSL {
 class DebugTrace;
+class DebugTracePriv;
 class ErrorReporter;
 class FunctionDefinition;
 struct Program;
@@ -43,7 +46,11 @@ struct ProgramSettings;
 
 namespace skvm {
 class Program;
-}  // namespace skvm
+}
+
+namespace SkSL::RP {
+class Program;
+}
 
 /*
  * SkRuntimeEffect supports creating custom SkShader and SkColorFilter objects using Skia's SkSL
@@ -126,9 +133,9 @@ public:
         friend class SkRuntimeEffect;
         friend class SkRuntimeEffectPriv;
 
-        // Public SkSL does not allow access to sk_FragCoord. The semantics of that variable are
-        // confusing, and expose clients to implementation details of saveLayer and image filters.
-        bool usePrivateRTShaderModule = false;
+        // This flag allows Runtime Effects to access Skia implementation details like sk_FragCoord
+        // and functions with private identifiers (e.g. $rgb_to_hsl).
+        bool allowPrivateAccess = false;
 
         // TODO(skia:11209) - Replace this with a promised SkCapabilities?
         // This flag lifts the ES2 restrictions on Runtime Effects that are gated by the
@@ -276,6 +283,7 @@ private:
         kSamplesOutsideMain_Flag = 0x10,
         kUsesColorTransform_Flag = 0x20,
         kAlwaysOpaque_Flag       = 0x40,
+        kAlphaUnchanged_Flag     = 0x80,
     };
 
     SkRuntimeEffect(std::unique_ptr<SkSL::Program> baseProgram,
@@ -301,15 +309,17 @@ private:
     bool samplesOutsideMain() const { return (fFlags & kSamplesOutsideMain_Flag); }
     bool usesColorTransform() const { return (fFlags & kUsesColorTransform_Flag); }
     bool alwaysOpaque()       const { return (fFlags & kAlwaysOpaque_Flag);       }
+    bool isAlphaUnchanged()   const { return (fFlags & kAlphaUnchanged_Flag);     }
 
     const SkFilterColorProgram* getFilterColorProgram() const;
+    const SkSL::RP::Program* getRPProgram(SkSL::DebugTracePriv* debugTrace) const;
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
     friend class GrSkSLFP;             // fBaseProgram, fSampleUsages
     friend class GrGLSLSkSLFP;         //
 #endif
 
-    friend class SkRTShader;            // fBaseProgram, fMain
+    friend class SkRTShader;            // fBaseProgram, fMain, fSampleUsages, getRPProgram()
     friend class SkRuntimeBlender;      //
     friend class SkRuntimeColorFilter;  //
 
@@ -319,6 +329,8 @@ private:
     uint32_t fHash;
 
     std::unique_ptr<SkSL::Program> fBaseProgram;
+    std::unique_ptr<SkSL::RP::Program> fRPProgram;
+    mutable SkOnce fCompileRPProgramOnce;
     const SkSL::FunctionDefinition& fMain;
     std::vector<Uniform> fUniforms;
     std::vector<Child> fChildren;
@@ -415,6 +427,11 @@ public:
     BuilderUniform uniform(std::string_view name) { return { this, fEffect->findUniform(name) }; }
     BuilderChild child(std::string_view name) { return { this, fEffect->findChild(name) }; }
 
+    // Get access to the collated uniforms and children (in the order expected by APIs like
+    // makeShader on the effect):
+    sk_sp<const SkData> uniforms() { return fUniforms; }
+    SkSpan<SkRuntimeEffect::ChildPtr> children() { return fChildren; }
+
 protected:
     SkRuntimeEffectBuilder() = delete;
     explicit SkRuntimeEffectBuilder(sk_sp<SkRuntimeEffect> effect)
@@ -432,10 +449,6 @@ protected:
     SkRuntimeEffectBuilder& operator=(SkRuntimeEffectBuilder&&) = delete;
     SkRuntimeEffectBuilder& operator=(const SkRuntimeEffectBuilder&) = delete;
 
-    sk_sp<const SkData> uniforms() { return fUniforms; }
-    SkRuntimeEffect::ChildPtr* children() { return fChildren.data(); }
-    size_t numChildren() { return fChildren.size(); }
-
 private:
     void* writableUniformData() {
         if (!fUniforms->unique()) {
@@ -492,6 +505,23 @@ private:
     friend class SkRuntimeImageFilter;
 };
 
+/**
+ * SkRuntimeColorFilterBuilder makes it easy to setup and assign uniforms to runtime color filters.
+ */
+class SK_API SkRuntimeColorFilterBuilder : public SkRuntimeEffectBuilder {
+public:
+    explicit SkRuntimeColorFilterBuilder(sk_sp<SkRuntimeEffect>);
+    ~SkRuntimeColorFilterBuilder();
+
+    SkRuntimeColorFilterBuilder(const SkRuntimeColorFilterBuilder&) = delete;
+    SkRuntimeColorFilterBuilder& operator=(const SkRuntimeColorFilterBuilder&) = delete;
+
+    sk_sp<SkColorFilter> makeColorFilter();
+
+private:
+    using INHERITED = SkRuntimeEffectBuilder;
+};
+
 /**
  * SkRuntimeBlendBuilder is a utility to simplify creation and uniform setup of runtime blenders.
  */

package/cpp/skia/include/encode/SkEncoder.h

@@ -9,8 +9,12 @@
 #define SkEncoder_DEFINED
 
 #include "include/core/SkPixmap.h"
-#include "include/private/SkNoncopyable.h"
-#include "include/private/SkTemplates.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkNoncopyable.h"
+#include "include/private/base/SkTemplates.h"
+
+#include <cstddef>
+#include <cstdint>
 
 class SK_API SkEncoder : SkNoncopyable {
 public:
@@ -53,7 +57,7 @@ protected:
 
     const SkPixmap&        fSrc;
     int                    fCurrRow;
-    SkAutoTMalloc<uint8_t> fStorage;
+    skia_private::AutoTMalloc<uint8_t> fStorage;
 };
 
 #endif

package/cpp/skia/include/encode/SkICC.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkICC_DEFINED
+#define SkICC_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+
+class SkData;
+struct skcms_ICCProfile;
+struct skcms_Matrix3x3;
+struct skcms_TransferFunction;
+
+SK_API sk_sp<SkData> SkWriteICCProfile(const skcms_TransferFunction&,
+                                       const skcms_Matrix3x3& toXYZD50);
+
+SK_API sk_sp<SkData> SkWriteICCProfile(const skcms_ICCProfile*, const char* description);
+
+// Utility function for populating the grid_16 member of skcms_A2B and skcms_B2A
+// structures. This converts a point in XYZD50 to its representation in grid_16_lab.
+// It will write 6 bytes. The behavior of this function matches how skcms will decode
+// values, but might not match the specification, see https://crbug.com/skia/13807.
+SK_API void SkICCFloatXYZD50ToGrid16Lab(const float* float_xyz, uint8_t* grid16_lab);
+
+// Utility function for popluating the table_16 member of skcms_Curve structure.
+// This converts a float to its representation in table_16. It will write 2 bytes.
+SK_API void SkICCFloatToTable16(const float f, uint8_t* table_16);
+
+#endif//SkICC_DEFINED

package/cpp/skia/include/encode/SkJpegEncoder.h

@@ -8,90 +8,121 @@
 #ifndef SkJpegEncoder_DEFINED
 #define SkJpegEncoder_DEFINED
 
-#include "include/encode/SkEncoder.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
 
-class SkJpegEncoderMgr;
+#include <memory>
+
+class SkColorSpace;
+class SkData;
+class SkEncoder;
+class SkPixmap;
 class SkWStream;
+class SkImage;
+class GrDirectContext;
+class SkYUVAPixmaps;
+struct skcms_ICCProfile;
+
+namespace SkJpegEncoder {
 
-class SK_API SkJpegEncoder : public SkEncoder {
-public:
-
-    enum class AlphaOption {
-        kIgnore,
-        kBlendOnBlack,
-    };
-
-    enum class Downsample {
-        /**
-         *  Reduction by a factor of two in both the horizontal and vertical directions.
-         */
-        k420,
-
-        /**
-         *  Reduction by a factor of two in the horizontal direction.
-         */
-        k422,
-
-        /**
-         *  No downsampling.
-         */
-        k444,
-    };
-
-    struct Options {
-        /**
-         *  |fQuality| must be in [0, 100] where 0 corresponds to the lowest quality.
-         */
-        int fQuality = 100;
-
-        /**
-         *  Choose the downsampling factor for the U and V components.  This is only
-         *  meaningful if the |src| is not kGray, since kGray will not be encoded as YUV.
-         *
-         *  Our default value matches the libjpeg-turbo default.
-         */
-        Downsample fDownsample = Downsample::k420;
-
-        /**
-         *  Jpegs must be opaque.  This instructs the encoder on how to handle input
-         *  images with alpha.
-         *
-         *  The default is to ignore the alpha channel and treat the image as opaque.
-         *  Another option is to blend the pixels onto a black background before encoding.
-         *  In the second case, the encoder supports linear or legacy blending.
-         */
-        AlphaOption fAlphaOption = AlphaOption::kIgnore;
-    };
+enum class AlphaOption {
+    kIgnore,
+    kBlendOnBlack,
+};
 
+enum class Downsample {
     /**
-     *  Encode the |src| pixels to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
-     *
-     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     *  Reduction by a factor of two in both the horizontal and vertical directions.
      */
-    static bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+    k420,
 
     /**
-     *  Create a jpeg encoder that will encode the |src| pixels to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
-     *
-     *  |dst| is unowned but must remain valid for the lifetime of the object.
-     *
-     *  This returns nullptr on an invalid or unsupported |src|.
+     *  Reduction by a factor of two in the horizontal direction.
      */
-    static std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src,
-                                           const Options& options);
+    k422,
 
-    ~SkJpegEncoder() override;
+    /**
+     *  No downsampling.
+     */
+    k444,
+};
+
+struct Options {
+    /**
+     *  |fQuality| must be in [0, 100] where 0 corresponds to the lowest quality.
+     */
+    int fQuality = 100;
+
+    /**
+     *  Choose the downsampling factor for the U and V components.  This is only
+     *  meaningful if the |src| is not kGray, since kGray will not be encoded as YUV.
+     *  This is ignored in favor of |src|'s subsampling when |src| is an SkYUVAPixmaps.
+     *
+     *  Our default value matches the libjpeg-turbo default.
+     */
+    Downsample fDownsample = Downsample::k420;
 
-protected:
-    bool onEncodeRows(int numRows) override;
+    /**
+     *  Jpegs must be opaque.  This instructs the encoder on how to handle input
+     *  images with alpha.
+     *
+     *  The default is to ignore the alpha channel and treat the image as opaque.
+     *  Another option is to blend the pixels onto a black background before encoding.
+     *  In the second case, the encoder supports linear or legacy blending.
+     */
+    AlphaOption fAlphaOption = AlphaOption::kIgnore;
 
-private:
-    SkJpegEncoder(std::unique_ptr<SkJpegEncoderMgr>, const SkPixmap& src);
+    /**
+     *  Optional XMP metadata.
+     */
+    const SkData* xmpMetadata = nullptr;
 
-    std::unique_ptr<SkJpegEncoderMgr> fEncoderMgr;
-    using INHERITED = SkEncoder;
+    /**
+     *  An optional ICC profile to override the default behavior.
+     *
+     *  The default behavior is to generate an ICC profile using a primary matrix and
+     *  analytic transfer function. If the color space of |src| cannot be represented
+     *  in this way (e.g, it is HLG or PQ), then no profile will be embedded.
+     */
+    const skcms_ICCProfile* fICCProfile = nullptr;
+    const char* fICCProfileDescription = nullptr;
 };
 
+/**
+ *  Encode the |src| pixels to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+ */
+SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+SK_API bool Encode(SkWStream* dst,
+                   const SkYUVAPixmaps& src,
+                   const SkColorSpace* srcColorSpace,
+                   const Options& options);
+
+/**
+*  Encode the provided image and return the resulting bytes. If the image was created as
+*  a texture-backed image on a GPU context, that |ctx| must be provided so the pixels
+*  can be read before being encoded. For raster-backed images, |ctx| can be nullptr.
+*  |options| may be used to control the encoding behavior.
+*
+*  Returns nullptr if the pixels could not be read or encoding otherwise fails.
+*/
+SK_API sk_sp<SkData> Encode(GrDirectContext* ctx, const SkImage* img, const Options& options);
+
+/**
+ *  Create a jpeg encoder that will encode the |src| pixels to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  |dst| is unowned but must remain valid for the lifetime of the object.
+ *
+ *  This returns nullptr on an invalid or unsupported |src|.
+ */
+SK_API std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src, const Options& options);
+SK_API std::unique_ptr<SkEncoder> Make(SkWStream* dst,
+                                       const SkYUVAPixmaps& src,
+                                       const SkColorSpace* srcColorSpace,
+                                       const Options& options);
+}  // namespace SkJpegEncoder
+
 #endif