@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -9,91 +9,109 @@
 #define SkPngEncoder_DEFINED
 
 #include "include/core/SkDataTable.h"
-#include "include/encode/SkEncoder.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
 
-class SkPngEncoderMgr;
+// TODO(kjlubick) update clients to directly include this
+#include "include/encode/SkEncoder.h"  // IWYU pragma: keep
+
+#include <memory>
+
+class GrDirectContext;
+class SkData;
+class SkImage;
+class SkPixmap;
 class SkWStream;
+struct skcms_ICCProfile;
+
+namespace SkPngEncoder {
+
+enum class FilterFlag : int {
+    kZero = 0x00,
+    kNone = 0x08,
+    kSub = 0x10,
+    kUp = 0x20,
+    kAvg = 0x40,
+    kPaeth = 0x80,
+    kAll = kNone | kSub | kUp | kAvg | kPaeth,
+};
 
-class SK_API SkPngEncoder : public SkEncoder {
-public:
-
-    enum class FilterFlag : int {
-        kZero  = 0x00,
-        kNone  = 0x08,
-        kSub   = 0x10,
-        kUp    = 0x20,
-        kAvg   = 0x40,
-        kPaeth = 0x80,
-        kAll   = kNone | kSub | kUp | kAvg | kPaeth,
-    };
-
-    struct Options {
-        /**
-         *  Selects which filtering strategies to use.
-         *
-         *  If a single filter is chosen, libpng will use that filter for every row.
-         *
-         *  If multiple filters are chosen, libpng will use a heuristic to guess which filter
-         *  will encode smallest, then apply that filter.  This happens on a per row basis,
-         *  different rows can use different filters.
-         *
-         *  Using a single filter (or less filters) is typically faster.  Trying all of the
-         *  filters may help minimize the output file size.
-         *
-         *  Our default value matches libpng's default.
-         */
-        FilterFlag fFilterFlags = FilterFlag::kAll;
-
-        /**
-         *  Must be in [0, 9] where 9 corresponds to maximal compression.  This value is passed
-         *  directly to zlib.  0 is a special case to skip zlib entirely, creating dramatically
-         *  larger pngs.
-         *
-         *  Our default value matches libpng's default.
-         */
-        int fZLibLevel = 6;
-
-        /**
-         *  Represents comments in the tEXt ancillary chunk of the png.
-         *  The 2i-th entry is the keyword for the i-th comment,
-         *  and the (2i + 1)-th entry is the text for the i-th comment.
-         */
-        sk_sp<SkDataTable> fComments;
-    };
+inline FilterFlag operator|(FilterFlag x, FilterFlag y) { return (FilterFlag)((int)x | (int)y); }
 
+struct Options {
     /**
-     *  Encode the |src| pixels to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
+     *  Selects which filtering strategies to use.
+     *
+     *  If a single filter is chosen, libpng will use that filter for every row.
+     *
+     *  If multiple filters are chosen, libpng will use a heuristic to guess which filter
+     *  will encode smallest, then apply that filter.  This happens on a per row basis,
+     *  different rows can use different filters.
+     *
+     *  Using a single filter (or less filters) is typically faster.  Trying all of the
+     *  filters may help minimize the output file size.
      *
-     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     *  Our default value matches libpng's default.
      */
-    static bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+    FilterFlag fFilterFlags = FilterFlag::kAll;
 
     /**
-     *  Create a png encoder that will encode the |src| pixels to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
+     *  Must be in [0, 9] where 9 corresponds to maximal compression.  This value is passed
+     *  directly to zlib.  0 is a special case to skip zlib entirely, creating dramatically
+     *  larger pngs.
      *
-     *  |dst| is unowned but must remain valid for the lifetime of the object.
-     *
-     *  This returns nullptr on an invalid or unsupported |src|.
+     *  Our default value matches libpng's default.
      */
-    static std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src,
-                                           const Options& options);
-
-    ~SkPngEncoder() override;
-
-protected:
-    bool onEncodeRows(int numRows) override;
+    int fZLibLevel = 6;
 
-    SkPngEncoder(std::unique_ptr<SkPngEncoderMgr>, const SkPixmap& src);
+    /**
+     *  Represents comments in the tEXt ancillary chunk of the png.
+     *  The 2i-th entry is the keyword for the i-th comment,
+     *  and the (2i + 1)-th entry is the text for the i-th comment.
+     */
+    sk_sp<SkDataTable> fComments;
 
-    std::unique_ptr<SkPngEncoderMgr> 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;
 };
 
-static inline SkPngEncoder::FilterFlag operator|(SkPngEncoder::FilterFlag x,
-                                                 SkPngEncoder::FilterFlag y) {
-    return (SkPngEncoder::FilterFlag)((int)x | (int)y);
-}
+/**
+ *  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);
+
+/**
+*  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 png encoder that will encode the |src| pixels to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  The primary use of this is incremental encoding of the pixels.
+ *
+ *  |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);
+
+}  // namespace SkPngEncoder
 
 #endif

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

@@ -8,58 +8,85 @@
 #ifndef SkWebpEncoder_DEFINED
 #define SkWebpEncoder_DEFINED
 
-#include "include/core/SkSpan.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h" // IWYU pragma: keep
 #include "include/encode/SkEncoder.h"
+#include "include/private/base/SkAPI.h"
 
+class SkPixmap;
 class SkWStream;
+class SkData;
+class GrDirectContext;
+class SkImage;
+struct skcms_ICCProfile;
 
 namespace SkWebpEncoder {
 
-    enum class Compression {
-        kLossy,
-        kLossless,
-    };
-
-    struct SK_API Options {
-        /**
-         *  |fCompression| determines whether we will use webp lossy or lossless compression.
-         *
-         *  |fQuality| must be in [0.0f, 100.0f].
-         *  If |fCompression| is kLossy, |fQuality| corresponds to the visual quality of the
-         *  encoding.  Decreasing the quality will result in a smaller encoded image.
-         *  If |fCompression| is kLossless, |fQuality| corresponds to the amount of effort
-         *  put into the encoding.  Lower values will compress faster into larger files,
-         *  while larger values will compress slower into smaller files.
-         *
-         *  This scheme is designed to match the libwebp API.
-         */
-        Compression fCompression = Compression::kLossy;
-        float fQuality = 100.0f;
-    };
+enum class Compression {
+    kLossy,
+    kLossless,
+};
 
+struct SK_API Options {
     /**
-     *  Encode the |src| pixels to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
+     *  |fCompression| determines whether we will use webp lossy or lossless compression.
+     *
+     *  |fQuality| must be in [0.0f, 100.0f].
+     *  If |fCompression| is kLossy, |fQuality| corresponds to the visual quality of the
+     *  encoding.  Decreasing the quality will result in a smaller encoded image.
+     *  If |fCompression| is kLossless, |fQuality| corresponds to the amount of effort
+     *  put into the encoding.  Lower values will compress faster into larger files,
+     *  while larger values will compress slower into smaller files.
      *
-     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     *  This scheme is designed to match the libwebp API.
      */
-    SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+    Compression fCompression = Compression::kLossy;
+    float fQuality = 100.0f;
 
     /**
-     *  Encode the |src| frames to the |dst| stream.
-     *  |options| may be used to control the encoding behavior.
-     *
-     *  The size of the first frame will be used as the canvas size. If any other frame does
-     *  not match the canvas size, this is an error.
-     *
-     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     * An optional ICC profile to override the default behavior.
      *
-     *  Note: libwebp API also supports set background color, loop limit and customize
-     *  lossy/lossless for each frame. These could be added later as needed.
+     * 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.
      */
-    SK_API bool EncodeAnimated(SkWStream* dst,
-                               SkSpan<const SkEncoder::Frame> src,
-                               const Options& options);
+    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);
+
+/**
+*  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);
+
+/**
+ *  Encode the |src| frames to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  The size of the first frame will be used as the canvas size. If any other frame does
+ *  not match the canvas size, this is an error.
+ *
+ *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+ *
+ *  Note: libwebp API also supports set background color, loop limit and customize
+ *  lossy/lossless for each frame. These could be added later as needed.
+ */
+SK_API bool EncodeAnimated(SkWStream* dst,
+                           SkSpan<const SkEncoder::Frame> src,
+                           const Options& options);
 } // namespace SkWebpEncoder
 
 #endif

package/cpp/skia/include/gpu/GpuTypes.h

@@ -26,16 +26,29 @@ enum class BackendApi : unsigned {
     kMock,
 };
 
+/** Indicates whether an allocation should count against a cache budget. */
+enum class Budgeted : bool {
+    kNo = false,
+    kYes = true,
+};
+
 /**
  * Value passed into various callbacks to tell the client the result of operations connected to a
  * specific callback. The actual interpretation of kFailed and kSuccess are dependent on the
  * specific callbacks and are documented with the callback itself.
  */
 enum class CallbackResult : bool {
-    kFailed = true,
+    kFailed = false,
     kSuccess = true,
 };
 
+/**
+ * Is the texture mipmapped or not
+ */
+enum class Mipmapped : bool {
+    kNo = false,
+    kYes = true,
+};
 
 /**
  * Is the data protected on the GPU or not.
@@ -45,6 +58,15 @@ enum class Protected : bool {
     kYes = true,
 };
 
+/**
+ * Is a texture renderable or not
+ */
+enum class Renderable : bool {
+    kNo = false,
+    kYes = true,
+};
+
 } // namespace skgpu
 
+
 #endif // skgpu_GpuTypes_DEFINED

package/cpp/skia/include/gpu/GrBackendSurface.h

@@ -35,6 +35,7 @@
 class GrVkImageLayout;
 class GrGLTextureParameters;
 class GrColorFormatDesc;
+enum class SkTextureCompressionType;
 
 namespace skgpu {
 class MutableTextureStateRef;
@@ -57,7 +58,7 @@ class GrD3DResourceState;
 class SkString;
 #endif
 
-#if !SK_SUPPORT_GPU
+#if !defined(SK_GANESH)
 
 // SkSurfaceCharacterization always needs a minimal version of this
 class SK_API GrBackendFormat {
@@ -124,7 +125,8 @@ public:
     }
 #endif
 
-    static GrBackendFormat MakeMock(GrColorType colorType, SkImage::CompressionType compression,
+    static GrBackendFormat MakeMock(GrColorType colorType,
+                                    SkTextureCompressionType compression,
                                     bool isStencilFormat = false);
 
     bool operator==(const GrBackendFormat& that) const;
@@ -191,7 +193,7 @@ public:
      * kUnknown, the compression type is not kNone, or this is a mock stencil format.
      */
     GrColorType asMockColorType() const;
-    SkImage::CompressionType asMockCompressionType() const;
+    SkTextureCompressionType asMockCompressionType() const;
     bool isMockStencilFormat() const;
 
     // If possible, copies the GrBackendFormat and forces the texture type to be Texture2D. If the
@@ -228,7 +230,7 @@ private:
     GrBackendFormat(DXGI_FORMAT dxgiFormat);
 #endif
 
-    GrBackendFormat(GrColorType, SkImage::CompressionType, bool isStencilFormat);
+    GrBackendFormat(GrColorType, SkTextureCompressionType, bool isStencilFormat);
 
 #ifdef SK_DEBUG
     bool validateMock() const;
@@ -259,9 +261,9 @@ private:
         DXGI_FORMAT fDxgiFormat;
 #endif
         struct {
-            GrColorType              fColorType;
-            SkImage::CompressionType fCompressionType;
-            bool                     fIsStencilFormat;
+            GrColorType fColorType;
+            SkTextureCompressionType fCompressionType;
+            bool fIsStencilFormat;
         } fMock;
     };
     GrTextureType fTextureType = GrTextureType::kNone;

package/cpp/skia/include/gpu/GrContextOptions.h

@@ -20,7 +20,7 @@
 
 class SkExecutor;
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
 struct SK_API GrContextOptions {
     enum class Enable {
         /** Forces an option to be disabled. */
@@ -80,8 +80,9 @@ struct SK_API GrContextOptions {
 
     /**
      * Controls whether we check for GL errors after functions that allocate resources (e.g.
-     * glTexImage2D), for shader compilation success, and program link success. Ignored on
-     * backends other than GL.
+     * glTexImage2D), at the end of a GPU submission, or checking framebuffer completeness. The
+     * results of shader compilation and program linking are always checked, regardless of this
+     * option. Ignored on backends other than GL.
      */
     Enable fSkipGLErrorChecks = Enable::kDefault;
 
@@ -244,6 +245,12 @@ struct SK_API GrContextOptions {
      */
     bool fSuppressMipmapSupport = false;
 
+    /**
+     * If true, the TessellationPathRenderer will not be used for path rendering.
+     * If false, will fallback to any driver workarounds, if set.
+     */
+    bool fDisableTessellationPathRenderer = false;
+
     /**
      * If true, and if supported, enables hardware tessellation in the caps.
      * DEPRECATED: This value is ignored; experimental hardware tessellation is always disabled.
@@ -254,13 +261,7 @@ struct SK_API GrContextOptions {
      * If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp
      * rendering of all glyphs. This must be set to true to use Slugs.
      */
-    #if defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG) || \
-        defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE) || \
-        defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_STRIKE_SERIALIZE)
-    bool fSupportBilerpFromGlyphAtlas = true;
-    #else
     bool fSupportBilerpFromGlyphAtlas = false;
-    #endif
 
     /**
      * Uses a reduced variety of shaders. May perform less optimally in steady state but can reduce
@@ -273,6 +274,24 @@ struct SK_API GrContextOptions {
      */
     bool fAllowMSAAOnNewIntel = false;
 
+    /**
+     * Currently on ARM Android we disable the use of GL TexStorage because of memory regressions.
+     * However, some clients may still want to use TexStorage. For example, TexStorage support is
+     * required for creating protected textures.
+     *
+     * This flag has no impact on non GL backends.
+     */
+    bool fAlwaysUseTexStorageWhenAvailable = false;
+
+    /**
+     * Optional callback that can be passed into the GrDirectContext which will be called when the
+     * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the
+     * client to delete the GPU backend context that is backing the GrDirectContext. The
+     * GrDirectContextDestroyedContext will be passed back to the client in the callback.
+     */
+    GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
+    GrDirectContextDestroyedProc fContextDeleteProc = nullptr;
+
 #if GR_TEST_UTILS
     /**
      * Private options that are only meant for testing within Skia's tools.

package/cpp/skia/include/gpu/GrContextThreadSafeProxy.h

@@ -10,9 +10,10 @@
 
 #include "include/core/SkRefCnt.h"
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
 
 #include "include/core/SkImageInfo.h"
+#include "include/gpu/GpuTypes.h"
 #include "include/gpu/GrContextOptions.h"
 #include "include/gpu/GrTypes.h"
 
@@ -25,6 +26,7 @@ class GrThreadSafeCache;
 class GrThreadSafePipelineBuilder;
 class SkSurfaceCharacterization;
 class SkSurfaceProps;
+enum class SkTextureCompressionType;
 
 namespace sktext::gpu { class TextBlobRedrawCoordinator; }
 
@@ -107,13 +109,13 @@ public:
     GrBackendFormat defaultBackendFormat(SkColorType ct, GrRenderable renderable) const;
 
     /**
-     * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is
+     * Retrieve the GrBackendFormat for a given SkTextureCompressionType. This is
      * guaranteed to match the backend format used by the following
      * createCompressedBackendTexture methods that take a CompressionType.
      *
      * The caller should check that the returned format is valid.
      */
-    GrBackendFormat compressedBackendFormat(SkImage::CompressionType c) const;
+    GrBackendFormat compressedBackendFormat(SkTextureCompressionType c) const;
 
     /**
      * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
@@ -160,7 +162,7 @@ private:
     std::atomic<bool>                                       fAbandoned{false};
 };
 
-#else // !SK_SUPPORT_GPU
+#else // !defined(SK_GANESH)
 class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};
 #endif