react-native-skia 0.0.1 → 3.0.0

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTableMaskFilter_DEFINED
+#define SkTableMaskFilter_DEFINED
+
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+#include <cstdint>
+
+class SkMaskFilter;
+
+/** \class SkTableMaskFilter
+
+    Applies a table lookup on each of the alpha values in the mask.
+    Helper methods create some common tables (e.g. gamma, clipping)
+ */
+// (DEPRECATED) These factory functions are deprecated. The TableMaskFilter will be
+// removed entirely in an upcoming release of Skia.
+class SK_API SkTableMaskFilter {
+public:
+    /** Utility that sets the gamma table
+     */
+    static void MakeGammaTable(uint8_t table[256], SkScalar gamma);
+
+    /** Utility that creates a clipping table: clamps values below min to 0
+        and above max to 255, and rescales the remaining into 0..255
+     */
+    static void MakeClipTable(uint8_t table[256], uint8_t min, uint8_t max);
+
+    static SkMaskFilter* Create(const uint8_t table[256]);
+    static SkMaskFilter* CreateGamma(SkScalar gamma);
+    static SkMaskFilter* CreateClip(uint8_t min, uint8_t max);
+
+    SkTableMaskFilter() = delete;
+
+private:
+    static void RegisterFlattenables();
+    friend class SkFlattenable;
+};
+
+#endif

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTrimPathEffect_DEFINED
+#define SkTrimPathEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPathEffect;
+
+class SK_API SkTrimPathEffect {
+public:
+    enum class Mode {
+        kNormal,   // return the subset path [start,stop]
+        kInverted, // return the complement/subset paths [0,start] + [stop,1]
+    };
+
+    /**
+     *  Take start and stop "t" values (values between 0...1), and return a path that is that
+     *  subset of the original path.
+     *
+     *  e.g.
+     *      Make(0.5, 1.0) --> return the 2nd half of the path
+     *      Make(0.33333, 0.66667) --> return the middle third of the path
+     *
+     *  The trim values apply to the entire path, so if it contains several contours, all of them
+     *  are including in the calculation.
+     *
+     *  startT and stopT must be 0..1 inclusive. If they are outside of that interval, they will
+     *  be pinned to the nearest legal value. If either is NaN, null will be returned.
+     *
+     *  Note: for Mode::kNormal, this will return one (logical) segment (even if it is spread
+     *        across multiple contours). For Mode::kInverted, this will return 2 logical
+     *        segments: stopT..1 and 0...startT, in this order.
+     */
+    static sk_sp<SkPathEffect> Make(SkScalar startT, SkScalar stopT, Mode = Mode::kNormal);
+};
+
+#endif

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncoder_DEFINED
+#define SkEncoder_DEFINED
+
+#include "include/core/SkPixmap.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkNoncopyable.h"
+#include "include/private/SkTemplates.h"
+
+#include <cstddef>
+#include <cstdint>
+
+class SK_API SkEncoder : SkNoncopyable {
+public:
+    /**
+     * A single frame to be encoded into an animated image.
+     *
+     * If a frame does not fit in the canvas size, this is an error.
+     * TODO(skbug.com/40044793): Add offsets when we have support for an encoder that supports using
+     * offsets.
+     */
+    struct SK_API Frame {
+        /**
+         *  Pixmap of the frame.
+         */
+        SkPixmap pixmap;
+        /**
+         *  Duration of the frame in millseconds.
+         */
+        int duration;
+    };
+
+    /**
+     *  Encode |numRows| rows of input.  If the caller requests more rows than are remaining
+     *  in the src, this will encode all of the remaining rows.  |numRows| must be greater
+     *  than zero.
+     */
+    bool encodeRows(int numRows);
+
+    virtual ~SkEncoder() {}
+
+protected:
+
+    virtual bool onEncodeRows(int numRows) = 0;
+
+    SkEncoder(const SkPixmap& src, size_t storageBytes)
+        : fSrc(src)
+        , fCurrRow(0)
+        , fStorage(storageBytes)
+    {}
+
+    const SkPixmap&        fSrc;
+    int                    fCurrRow;
+    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/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 skbug.com/40044907.
+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

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegEncoder_DEFINED
+#define SkJpegEncoder_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <memory>
+#include <optional>
+
+class SkColorSpace;
+class SkData;
+class SkEncoder;
+class SkPixmap;
+class SkWStream;
+class SkImage;
+class GrDirectContext;
+class SkYUVAPixmaps;
+struct skcms_ICCProfile;
+
+namespace SkJpegEncoder {
+
+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.
+     *  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;
+
+    /**
+     *  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;
+
+    /**
+     *  Optional XMP metadata.
+     */
+    const SkData* xmpMetadata = nullptr;
+
+    std::optional<SkEncodedOrigin> fOrigin;
+};
+
+/**
+ *  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);
+
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(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 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

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

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPngEncoder_DEFINED
+#define SkPngEncoder_DEFINED
+
+#include "include/core/SkDataTable.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkHdrMetadata.h"
+
+// 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;
+struct SkGainmapInfo;
+
+namespace SkPngEncoder {
+
+enum class FilterFlag : int {
+    kZero = 0x00,
+    kNone = 0x08,
+    kSub = 0x10,
+    kUp = 0x20,
+    kAvg = 0x40,
+    kPaeth = 0x80,
+    kAll = kNone | kSub | kUp | kAvg | kPaeth,
+};
+
+inline FilterFlag operator|(FilterFlag x, FilterFlag y) { return (FilterFlag)((int)x | (int)y); }
+
+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;
+
+    /**
+     * Container for any HDR metadata to include in the encoded image.
+     */
+    skhdr::Metadata fHdrMetadata;
+
+    /**
+     * If non-null, then a gainmap and its metadata will be encoded as png chunks.
+     * The gainmap will be encoded in a gmAP chunk as a full PNG container. The
+     * gainmap info will be encoded in a gdAT chunk inside of the gmAP chunk.
+     * This effectively is Option B proposed in this discussion for adding gainmaps
+     * into PNG: https://github.com/w3c/png/issues/380#issuecomment-2325163149.
+     *
+     * Note that if fGainmapInfo is null, then fGainmap will fail to encode, as the
+     * gainmap metadata is required to correctly interpret the encoded gainmap.
+     */
+    const SkPixmap* fGainmap = nullptr;
+    const SkGainmapInfo* fGainmapInfo = 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);
+
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(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/SkPngRustEncoder.h

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPngRustEncoder_DEFINED
+#define SkPngRustEncoder_DEFINED
+
+#include <cstdint>
+#include <memory>
+
+#include "include/core/SkDataTable.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class GrDirectContext;
+class SkData;
+class SkEncoder;
+class SkImage;
+class SkPixmap;
+class SkWStream;
+
+struct SkGainmapInfo;
+
+namespace SkPngRustEncoder {
+
+/*
+ * Compression level.
+ */
+enum class CompressionLevel : uint8_t {
+    // Low compression level - fast, but may result in bigger PNG files.
+    kLow,
+
+    // Medium compression level - somewhere in-between `kLow` and `kHigh`.
+    kMedium,
+
+    // High compression level - slow, but should results in smaller PNG files.
+    kHigh,
+};
+
+/*
+ * PNG encoding options.
+ *
+ * TODO(https://crbug.com/379312510): Add support for `SkPngEncoder::Options`
+ * like:
+ *  - Comments - `tEXt` chunks.
+ *  - Color profile - `iCCP` chunk.
+ */
+struct Options {
+    CompressionLevel fCompressionLevel = CompressionLevel::kMedium;
+
+    /**
+     *  Represents comments to be written into tEXt chunks 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.
+     *
+     *  All entries are treated as strings encoded as Latin-1 (i.e.
+     *  ISO-8859-1).  The strings may, but don't have to be NUL-terminated
+     *  (trailing NUL characters will be stripped).  Encoding will fail if
+     *  keyword or text don't meet the requirements of the PNG spec - text may
+     *  have any length and contain any of the 191 Latin-1 characters (and/or
+     *  the linefeed character), but keyword's length is restricted to at most
+     *  79 characters and it can't contain a non-breaking space character.
+     */
+    sk_sp<SkDataTable> fComments;
+
+    /**
+     * If non-null, then a gainmap and its metadata will be encoded as png chunks.
+     * The gainmap metadata (info) will be encoded in a gmAP chunk. The
+     * gainmap pixels (encoded as a PNG) will be encoded in a gdAT chunk.
+     * This effectively is Option B proposed in this discussion for adding gainmaps
+     * into PNG: https://github.com/w3c/png/issues/380#issuecomment-2325163149.
+     *
+     * Note that if fGainmapInfo is null, then fGainmap will be ignored (not encoded),
+     * as the gainmap metadata is required to correctly interpret the encoded gainmap.
+     */
+    const SkPixmap* fGainmap = nullptr;
+    const SkGainmapInfo* fGainmapInfo = 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);
+
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(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 SkPngRustEncoder
+
+#endif  // SkPngRustEncoder_DEFINED

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkWebpEncoder_DEFINED
+#define SkWebpEncoder_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h" // IWYU pragma: keep
+#include "include/encode/SkEncoder.h"
+#include "include/private/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;
+};
+
+/**
+ *  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);
+
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(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