@shopify/react-native-skia 1.12.0 → 1.12.1

package/cpp/skia/include/core/SkColorType.h

@@ -15,43 +15,125 @@
 
     kN32_SkColorType selects the native 32-bit ARGB format for the current configuration. This can
     lead to inconsistent results across platforms, so use with caution.
-*/
-enum SkColorType : int {
-    kUnknown_SkColorType,      //!< uninitialized
-    kAlpha_8_SkColorType,      //!< pixel with alpha in 8-bit byte
-    kRGB_565_SkColorType,      //!< pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
-    kARGB_4444_SkColorType,    //!< pixel with 4 bits for alpha, red, green, blue; in 16-bit word
-    kRGBA_8888_SkColorType,    //!< pixel with 8 bits for red, green, blue, alpha; in 32-bit word
-    kRGB_888x_SkColorType,     //!< pixel with 8 bits each for red, green, blue; in 32-bit word
-    kBGRA_8888_SkColorType,    //!< pixel with 8 bits for blue, green, red, alpha; in 32-bit word
-    kRGBA_1010102_SkColorType, //!< 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
-    kBGRA_1010102_SkColorType, //!< 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
-    kRGB_101010x_SkColorType,  //!< pixel with 10 bits each for red, green, blue; in 32-bit word
-    kBGR_101010x_SkColorType,  //!< pixel with 10 bits each for blue, green, red; in 32-bit word
-    kBGR_101010x_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
-    kBGRA_10101010_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red, alpha; in 64-bit word, extended range
-    kRGBA_10x6_SkColorType,    //!< pixel with 10 used bits (most significant) followed by 6 unused
-                               //   bits for red, green, blue, alpha; in 64-bit word
-    kGray_8_SkColorType,       //!< pixel with grayscale level in 8-bit byte
-    kRGBA_F16Norm_SkColorType, //!< pixel with half floats in [0,1] for red, green, blue, alpha;
-                               //   in 64-bit word
-    kRGBA_F16_SkColorType,     //!< pixel with half floats for red, green, blue, alpha;
-                               //   in 64-bit word
-    kRGB_F16F16F16x_SkColorType,     //!< pixel with half floats for red, green, blue; in 64-bit word
-    kRGBA_F32_SkColorType,     //!< pixel using C float for red, green, blue, alpha; in 128-bit word
 
-    // The following 6 colortypes are just for reading from - not for rendering to
-    kR8G8_unorm_SkColorType,         //!< pixel with a uint8_t for red and green
+    By default, Skia operates with the assumption of a little-Endian system. The names of each
+    SkColorType implicitly define the channel ordering and size in memory. Due to historical reasons
+    the names do not follow 100% identical convention, but are typically labeled from least
+    significant to most significant. To help clarify when the actual data layout differs from the
+    default convention, every SkColorType's comment includes a bit-labeled description of a pixel
+    in that color type on a LE system.
 
-    kA16_float_SkColorType,          //!< pixel with a half float for alpha
-    kR16G16_float_SkColorType,       //!< pixel with a half float for red and green
+    Unless specified otherwise, a channel's value is treated as an unsigned integer with a range of
+    of [0, 2^N-1] and this is mapped uniformly to a floating point value of [0.0, 1.0]. Some color
+    types instead store data directly in 32-bit floating point (assumed to be IEEE), or in 16-bit
+    "half" floating point values. A half float, or F16/float16, is interpreted as FP 1-5-10 or
+       Bits: [sign:15 exp:14..10 man:9..0]
+*/
+enum SkColorType : int {
+    // Unknown or unrepresentable as an SkColorType.
+    kUnknown_SkColorType,
+    // Single channel data (8-bit) interpreted as an alpha value. RGB are 0.
+    //   Bits: [A:7..0]
+    kAlpha_8_SkColorType,
+    // Three channel BGR data (5 bits red, 6 bits green, 5 bits blue) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..11 G:10..5 B:4..0]
+    kRGB_565_SkColorType,
+    // Four channel ABGR data (4 bits per channel) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..12 G:11..8 B:7..4 A:3..0]
+    kARGB_4444_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
+    kRGBA_8888_SkColorType,
+    // Three channel RGB data (8 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..24 B:23..16 G:15..8 R:7..0]
+    kRGB_888x_SkColorType,
+    // Four channel BGRA data (8 bits per channel) packed into a LE 32-bit word. R and B are swapped
+    // relative to kRGBA_8888.
+    //   Bits: [A:31..24 R:23..16 G:15..8 B:7..0]
+    kBGRA_8888_SkColorType,
+    // Four channel RGBA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    //   Bits: [A:31..30 B:29..20 G:19..10 R:9..0]
+    kRGBA_1010102_SkColorType,
+    // Four channel BGRA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    // R and B are swapped relative to kRGBA_1010102.
+    //   Bits: [A:31..30 R:29..20 G:19..10 B:9..0]
+    kBGRA_1010102_SkColorType,
+    // Three channel RGB data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..30 B:29..20 G:19..10 R:9..0]
+    kRGB_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. R and B are swapped relative to kRGB_101010x.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. Instead of normalizing [0, 1023] to [0.0, 1.0] the
+    // color channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGR10_XR.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_XR_SkColorType,
+    // Four channel BGRA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.  Instead of normalizing [0, 1023] to [0.0, 1.0] the color and
+    // alpha channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGRA10_XR.
+    //   Bits: [A:63..54 x:53..48 R:47..38 x:37..32 G:31..22 x:21..16 B:15..6 x:5..0]
+    kBGRA_10101010_XR_SkColorType,
+    // Four channel RGBA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.
+    //   Bits: [A:63..54 x:53..48 B:47..38 x:37..32 G:31..22 x:21..16 R:15..6 x:5..0]
+    kRGBA_10x6_SkColorType,
+    // Single channel data (8-bit) interpreted as a grayscale value (e.g. replicated to RGB).
+    //   Bits: [G:7..0]
+    kGray_8_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word. Values
+    // are assumed to be in [0.0,1.0] range, unlike kRGBA_F16.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16Norm_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word.
+    // This has extended range compared to kRGBA_F16Norm.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16_SkColorType,
+    // Three channel RGB data (16-bit half-float per channel) packed into a LE 64-bit word. The last
+    // 16 bits are ignored and alpha is forced to opaque.
+    //   Bits: [x:63..48 B:47..32 G:31..16 R:15..0]
+    kRGB_F16F16F16x_SkColorType,
+    // Four channel RGBA data (32-bit float per channel) packed into a LE 128-bit word.
+    //   Bits: [A:127..96 B:95..64 G:63..32 R:31..0]
+    kRGBA_F32_SkColorType,
 
-    kA16_unorm_SkColorType,          //!< pixel with a little endian uint16_t for alpha
-    kR16G16_unorm_SkColorType,       //!< pixel with a little endian uint16_t for red and green
-    kR16G16B16A16_unorm_SkColorType, //!< pixel with a little endian uint16_t for red, green, blue
-                                     //   and alpha
+    // The following 8 colortypes are just for reading from - not for rendering to
 
+    // Two channel RG data (8 bits per channel). Blue is forced to 0, alpha is forced to opaque.
+    //   Bits: [G:15..8 R:7..0]
+    kR8G8_unorm_SkColorType,
+    // Single channel data (16-bit half-float) interpreted as alpha. RGB are 0.
+    //   Bits: [A:15..0]
+    kA16_float_SkColorType,
+    // Two channel RG data (16-bit half-float per channel) packed into a LE 32-bit word.
+    // Blue is forced to 0, alpha is forced to opaque.
+    //   Bits: [G:31..16 R:15..0]
+    kR16G16_float_SkColorType,
+    // Single channel data (16 bits) interpreted as alpha. RGB are 0.
+    //   Bits: [A:15..0]
+    kA16_unorm_SkColorType,
+    // Two channel RG data (16 bits per channel) packed into a LE 32-bit word. B is forced to 0,
+    // alpha is forced to opaque.
+    //   Bits: [G:31..16 R:15..0]
+    kR16G16_unorm_SkColorType,
+    // Four channel RGBA data (16 bits per channel) packed into a LE 64-bit word.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kR16G16B16A16_unorm_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word. The RGB values are
+    // assumed to be encoded with the sRGB transfer function, which can be decoded automatically
+    // by GPU hardware with certain texture formats.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
     kSRGBA_8888_SkColorType,
+    // Single channel data (8 bits) interpreted as red. G and B are forced to 0, alpha is forced to
+    // opaque.
+    //    Bits: [R:7..0]
     kR8_unorm_SkColorType,
 
     kLastEnum_SkColorType     = kR8_unorm_SkColorType, //!< last valid value

package/cpp/skia/include/core/SkFontScanner.h

@@ -9,6 +9,7 @@
 #define SKFONTSCANNER_H_
 
 #include "include/core/SkFontArguments.h"
+#include "include/core/SkFontParameters.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkFixed.h"
@@ -22,13 +23,8 @@ class SkTypeface;
 class SkFontScanner : public SkNoncopyable {
 public:
     virtual ~SkFontScanner() = default;
-    struct AxisDefinition {
-        SkFourByteTag fTag;
-        SkScalar fMinimum;
-        SkScalar fDefault;
-        SkScalar fMaximum;
-    };
-    typedef skia_private::STArray<4, AxisDefinition, true> AxisDefinitions;
+    using AxisDefinitions = skia_private::STArray<4, SkFontParameters::Variation::Axis, true>;
+    using VariationPosition = skia_private::STArray<4, SkFontArguments::VariationPosition::Coordinate, true>;
 
     virtual bool scanFile(SkStreamAsset* stream, int* numFaces) const = 0;
     virtual bool scanFace(SkStreamAsset* stream, int faceIndex, int* numInstances) const = 0;
@@ -39,7 +35,8 @@ public:
                               SkString* name,
                               SkFontStyle* style,
                               bool* isFixedPitch,
-                              AxisDefinitions* axes) const = 0;
+                              AxisDefinitions* axes,
+                              VariationPosition* position) const = 0;
     virtual sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream,
                                              const SkFontArguments& args) const = 0;
     virtual SkFourByteTag getFactoryId() const = 0;

package/cpp/skia/include/core/SkFontStyle.h

@@ -41,7 +41,7 @@ public:
         kUltraExpanded_Width    = 9,
     };
 
-    enum Slant {
+    enum Slant : uint8_t {
         kUpright_Slant,
         kItalic_Slant,
         kOblique_Slant,

package/cpp/skia/include/core/SkMaskFilter.h

@@ -17,7 +17,6 @@
 
 enum SkBlurStyle : int;
 struct SkDeserialProcs;
-struct SkRect;
 
 /** \class SkMaskFilter
 
@@ -35,13 +34,6 @@ public:
     static sk_sp<SkMaskFilter> MakeBlur(SkBlurStyle style, SkScalar sigma,
                                         bool respectCTM = true);
 
-    /**
-     *  Returns the approximate bounds that would result from filtering the src rect.
-     *  The actual result may be different, but it should be contained within the
-     *  returned bounds.
-     */
-    SkRect approximateFilteredBounds(const SkRect& src) const;
-
     static sk_sp<SkMaskFilter> Deserialize(const void* data, size_t size,
                                            const SkDeserialProcs* procs = nullptr);
 

package/cpp/skia/include/core/SkMilestone.h

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 132
+#define SK_MILESTONE 134
 #endif

package/cpp/skia/include/core/SkPath.h

@@ -1909,7 +1909,7 @@ private:
     void shrinkToFit();
 
     // Creates a new Path after the supplied arguments have been validated by
-    // sk_path_analyze_verbs().
+    // SkPathPriv::AnalyzeVerbs().
     static SkPath MakeInternal(const SkPathVerbAnalysis& analsis,
                                const SkPoint points[],
                                const uint8_t verbs[],

package/cpp/skia/include/core/SkRRect.h

@@ -13,6 +13,7 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkMacros.h"
 
 #include <cstdint>
 #include <cstring>
@@ -33,6 +34,7 @@ class SkString;
     If either axis radii is zero or less: radii are stored as zero; corner is square.
     If corner curves overlap, radii are proportionally reduced to fit within bounds.
 */
+SK_BEGIN_REQUIRE_DENSE
 class SK_API SkRRect {
 public:
 
@@ -511,11 +513,11 @@ private:
     SkVector fRadii[4] = {{0, 0}, {0, 0}, {0,0}, {0,0}};
     // use an explicitly sized type so we're sure the class is dense (no uninitialized bytes)
     int32_t fType = kEmpty_Type;
-    // TODO: add padding so we can use memcpy for flattening and not copy uninitialized data
 
     // to access fRadii directly
     friend class SkPath;
     friend class SkRRectPriv;
 };
+SK_END_REQUIRE_DENSE
 
 #endif

package/cpp/skia/include/core/SkShader.h

@@ -25,9 +25,9 @@ struct SkSamplingOptions;
 
 /** \class SkShader
  *
- *  Shaders specify the source color(s) for what is being drawn. If a paint
- *  has no shader, then the paint's color is used. If the paint has a
- *  shader, then the shader's color(s) are use instead, but they are
+ *  Shaders specify the premultiplied source color(s) for what is being drawn.
+ *  If a paint has no shader, then the paint's color is used. If the paint has a
+ *  shader, then the shader's color(s) are used instead, but they are
  *  modulated by the paint's alpha. This makes it easy to create a shader
  *  once (e.g. bitmap tiling or gradient) and then change its transparency
  *  w/o having to modify the original shader... only the paint's alpha needs

package/cpp/skia/include/core/SkString.h

@@ -28,13 +28,13 @@ static inline bool SkStrStartsWith(const char string[], const char prefixStr[])
     SkASSERT(prefixStr);
     return !strncmp(string, prefixStr, strlen(prefixStr));
 }
-static inline bool SkStrStartsWith(const char string[], const char prefixChar) {
+static inline bool SkStrStartsWith(const char string[], char prefixChar) {
     SkASSERT(string);
     return (prefixChar == *string);
 }
 
 bool SkStrEndsWith(const char string[], const char suffixStr[]);
-bool SkStrEndsWith(const char string[], const char suffixChar);
+bool SkStrEndsWith(const char string[], char suffixChar);
 
 int SkStrStartsWithOneOf(const char string[], const char prefixes[]);
 
@@ -44,7 +44,7 @@ static inline int SkStrFind(const char string[], const char substring[]) {
     return SkToInt(first - &string[0]);
 }
 
-static inline int SkStrFindLastOf(const char string[], const char subchar) {
+static inline int SkStrFindLastOf(const char string[], char subchar) {
     const char* last = strrchr(string, subchar);
     if (nullptr == last) return -1;
     return SkToInt(last - &string[0]);
@@ -55,7 +55,7 @@ static inline bool SkStrContains(const char string[], const char substring[]) {
     SkASSERT(substring);
     return (-1 != SkStrFind(string, substring));
 }
-static inline bool SkStrContains(const char string[], const char subchar) {
+static inline bool SkStrContains(const char string[], char subchar) {
     SkASSERT(string);
     char tmp[2];
     tmp[0] = subchar;
@@ -142,25 +142,25 @@ public:
     bool startsWith(const char prefixStr[]) const {
         return SkStrStartsWith(fRec->data(), prefixStr);
     }
-    bool startsWith(const char prefixChar) const {
+    bool startsWith(char prefixChar) const {
         return SkStrStartsWith(fRec->data(), prefixChar);
     }
     bool endsWith(const char suffixStr[]) const {
         return SkStrEndsWith(fRec->data(), suffixStr);
     }
-    bool endsWith(const char suffixChar) const {
+    bool endsWith(char suffixChar) const {
         return SkStrEndsWith(fRec->data(), suffixChar);
     }
     bool contains(const char substring[]) const {
         return SkStrContains(fRec->data(), substring);
     }
-    bool contains(const char subchar) const {
+    bool contains(char subchar) const {
         return SkStrContains(fRec->data(), subchar);
     }
     int find(const char substring[]) const {
         return SkStrFind(fRec->data(), substring);
     }
-    int findLastOf(const char subchar) const {
+    int findLastOf(char subchar) const {
         return SkStrFindLastOf(fRec->data(), subchar);
     }
 

package/cpp/skia/include/core/SkSurface.h

@@ -330,6 +330,20 @@ public:
      */
     sk_sp<SkImage> makeImageSnapshot(const SkIRect& bounds);
 
+    /** Returns an SkImage capturing the current SkSurface contents. However, the contents of the
+        SkImage are only valid as long as no other writes to the SkSurface occur. If writes to the
+        original SkSurface happen then contents of the SkImage are undefined. However, continued use
+        of the SkImage should not cause crashes or similar fatal behavior.
+
+        This API is useful for cases where the client either immediately destroys the SkSurface
+        after the SkImage is created or knows they will destroy the SkImage before writing to the
+        SkSurface again.
+
+        This API can be more performant than makeImageSnapshot as it never does an internal copy
+        of the data assuming the user frees either the SkImage or SkSurface as described above.
+     */
+    sk_sp<SkImage> makeTemporaryImage();
+
     /** Draws SkSurface contents to canvas, with its top-left corner at (x, y).
 
         If SkPaint paint is not nullptr, apply SkColorFilter, alpha, SkImageFilter, and SkBlendMode.

package/cpp/skia/include/core/SkTypeface.h

@@ -53,20 +53,18 @@ typedef uint32_t SkFontTableTag;
 class SK_API SkTypeface : public SkWeakRefCnt {
 public:
     /** Returns the typeface's intrinsic style attributes. */
-    SkFontStyle fontStyle() const {
-        return fStyle;
-    }
+    SkFontStyle fontStyle() const;
 
     /** Returns true if style() has the kBold bit set. */
-    bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; }
+    bool isBold() const;
 
     /** Returns true if style() has the kItalic bit set. */
-    bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; }
+    bool isItalic() const;
 
     /** Returns true if the typeface claims to be fixed-pitch.
      *  This is a style bit, advance widths may vary even if this returns true.
      */
-    bool isFixedPitch() const { return fIsFixedPitch; }
+    bool isFixedPitch() const;
 
     /** Copy into 'coordinates' (allocated by the caller) the design variation coordinates.
      *
@@ -287,6 +285,20 @@ public:
      */
     bool getPostScriptName(SkString* name) const;
 
+    /**
+     *  If the primary resource backing this typeface has a name (like a file
+     *  path or URL) representable by unicode code points, the `resourceName`
+     *  will be set. The primary purpose is as a user facing indication about
+     *  where the data was obtained (which font file was used).
+     *
+     *  Returns the number of resources backing this typeface.
+     *
+     *  For local font collections resource name will often be a file path. The
+     *  file path may or may not exist. If it does exist, using it to create an
+     *  SkTypeface may or may not create a similar SkTypeface to this one.
+     */
+    int getResourceName(SkString* resourceName) const;
+
     /**
      *  Return a stream for the contents of the font data, or NULL on failure.
      *  If ttcIndex is not null, it is set to the TrueTypeCollection index
@@ -349,6 +361,10 @@ protected:
     /** Sets the font style. If used, must be called in the constructor. */
     void setFontStyle(SkFontStyle style) { fStyle = style; }
 
+    virtual SkFontStyle onGetFontStyle() const; // TODO: = 0;
+
+    virtual bool onGetFixedPitch() const; // TODO: = 0;
+
     // Must return a valid scaler context. It can not return nullptr.
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
                                                                    const SkDescriptor*) const = 0;
@@ -398,6 +414,7 @@ protected:
      */
     virtual void onGetFamilyName(SkString* familyName) const = 0;
     virtual bool onGetPostScriptName(SkString*) const = 0;
+    virtual int onGetResourceName(SkString* resourceName) const; // TODO: = 0;
 
     /** Returns an iterator over the family names in the font. */
     virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0;
@@ -424,7 +441,7 @@ private:
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
-    friend class SkTypeface_fontconfig;
+    friend class SkTypeface_proxy;
 
     friend class SkFontPriv;         // getGlyphToUnicodeMap
 

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

@@ -94,7 +94,12 @@ public:
             kHSL,
             kHWB,
 
-            kLastColorSpace = kHWB,
+            kDisplayP3,
+            kRec2020,
+            kProphotoRGB,
+            kA98RGB,
+
+            kLastColorSpace = kA98RGB,
         };
         static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1;
 

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

@@ -170,6 +170,7 @@ public:
 
     // Shader SkSL requires an entry point that looks like:
     //     vec4 main(vec2 inCoords) { ... }
+    // The color that is returned should be premultiplied.
     static Result MakeForShader(SkString sksl, const Options&);
     static Result MakeForShader(SkString sksl) {
         return MakeForShader(std::move(sksl), Options{});

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

@@ -23,6 +23,7 @@ class SkImage;
 class SkPixmap;
 class SkWStream;
 struct skcms_ICCProfile;
+struct SkGainmapInfo;
 
 namespace SkPngEncoder {
 
@@ -80,6 +81,19 @@ struct Options {
      */
     const skcms_ICCProfile* fICCProfile = nullptr;
     const char* fICCProfileDescription = nullptr;
+
+    /**
+     * 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;
 };
 
 /**

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

@@ -79,6 +79,15 @@ enum class Origin : unsigned {
     kBottomLeft,
 };
 
+enum class GpuStatsFlags : uint32_t {
+    kNone = 0b00,
+    kElapsedTime = 0b01,
+};
+
+struct GpuStats {
+    uint64_t elapsedTime = 0;
+};
+
 } // namespace skgpu