@shopify/react-native-skia 2.3.0 → 2.3.5

package/cpp/skia/include/gpu/graphite/precompile/PrecompileBase.h

@@ -15,7 +15,6 @@ namespace skgpu::graphite {
 
 class KeyContext;
 class PaintParamsKeyBuilder;
-class PipelineDataGatherer;
 class PrecompileBasePriv;
 
 /** \class PrecompileBase
@@ -51,10 +50,7 @@ protected:
         return this->numIntrinsicCombinations() * this->numChildCombinations();
     }
 
-    virtual void addToKey(const KeyContext&,
-                          PaintParamsKeyBuilder*,
-                          PipelineDataGatherer*,
-                          int desiredCombination) const = 0;
+    virtual void addToKey(const KeyContext&, int desiredCombination) const = 0;
 
     // This returns the desired option along with the child options.
     template<typename T>
@@ -64,11 +60,7 @@ protected:
     // In general, derived classes should use AddToKey to select the desired child option from
     // a span and then have it added to the key with its reduced/nested child option.
     template<typename T>
-    static void AddToKey(const KeyContext&,
-                         PaintParamsKeyBuilder*,
-                         PipelineDataGatherer*,
-                         SkSpan<const sk_sp<T>> options,
-                         int desiredOption);
+    static void AddToKey(const KeyContext&, SkSpan<const sk_sp<T>> options, int desiredOption);
 
 private:
     friend class PrecompileBasePriv;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileImageFilter.h

@@ -52,20 +52,15 @@ private:
     // The PrecompileImageFilter classes do not use the PrecompileBase::addToKey virtual since
     // they, in general, do not themselves contribute to a given SkPaint/Pipeline but, rather,
     // create separate SkPaints/Pipelines from whole cloth (in onCreatePipelines).
-    void addToKey(const KeyContext& /* keyContext */,
-                  PaintParamsKeyBuilder* /* builder */,
-                  PipelineDataGatherer* /* gatherer */,
-                  int /* desiredCombination */) const final {
+    void addToKey(const KeyContext& /* keyContext */, int /* desiredCombination */) const final {
         SkASSERT(false);
     }
 
     virtual void onCreatePipelines(const KeyContext&,
-                                   PipelineDataGatherer*,
                                    const RenderPassDesc&,
                                    const PaintOptions::ProcessCombination&) const = 0;
 
     void createPipelines(const KeyContext&,
-                         PipelineDataGatherer*,
                          const RenderPassDesc&,
                          const PaintOptions::ProcessCombination&);
 

package/cpp/skia/include/gpu/graphite/precompile/PrecompileMaskFilter.h

@@ -24,13 +24,9 @@ protected:
     PrecompileMaskFilter() : PrecompileBase(Type::kMaskFilter) {}
     ~PrecompileMaskFilter() override;
 
-    void addToKey(const KeyContext&,
-                  PaintParamsKeyBuilder*,
-                  PipelineDataGatherer*,
-                  int desiredCombination) const final;
+    void addToKey(const KeyContext&, int desiredCombination) const final;
 
     virtual void createPipelines(const KeyContext&,
-                                 PipelineDataGatherer*,
                                  const PaintOptions&,
                                  const RenderPassDesc&,
                                  const PaintOptions::ProcessCombination&) const = 0;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileShader.h

@@ -72,7 +72,8 @@ public:
      *     sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source1, source2 },
      *                                                                 { colorSpace });
      */
-    sk_sp<PrecompileShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace>) const;
+    sk_sp<PrecompileShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace> inputCS,
+                                                      sk_sp<SkColorSpace> outputCS=nullptr) const;
 
     // Provides access to functions that aren't part of the public API.
     PrecompileShaderPriv priv();
@@ -244,8 +245,20 @@ namespace PrecompileShaders {
     // WorkingColorSpaceShaders (i.e., pass SkSpans to the factory function vs just creating a
     // single option). This entry point allows that use case.
     // Note: PrecompileShader::makeWithWorkingColorSpace can still be used and works as expected.
-    SK_API sk_sp<PrecompileShader> WorkingColorSpace(SkSpan<const sk_sp<PrecompileShader>> shaders,
-                                                     SkSpan<const sk_sp<SkColorSpace>> colorSpaces);
+
+    // This variant creates the cross product of `inputSpaces` and `outputSpaces`.
+    // An empty list is interpreted as matching either the dst color space (for `inputSpaces`) or
+    // matching the input space (for `outputSpaces`).
+    SK_API sk_sp<PrecompileShader> WorkingColorSpace(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const sk_sp<SkColorSpace>> inputSpaces,
+            SkSpan<const sk_sp<SkColorSpace>> outputSpaces = {});
+
+    // This variant takes a span of input and output color spaces pairs explicitly.
+    SK_API sk_sp<PrecompileShader> WorkingColorSpaceExplicit(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const std::pair</*input =*/sk_sp<SkColorSpace>,
+                                   /*output=*/sk_sp<SkColorSpace>>> inputAndOutputSpaces);
 
 } // namespace PrecompileShaders
 

package/cpp/skia/include/gpu/vk/VulkanPreferredFeatures.h

@@ -189,6 +189,9 @@ private:
     // Feature of VK_EXT_pipeline_creation_cache_control or Vulkan 1.3
     VkPhysicalDevicePipelineCreationCacheControlFeatures fPipelineCreationCacheControl = {};
 
+    // Feature of VK_EXT_frame_boundary
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT fFrameBoundary = {};
+
     // Extensions that don't have a feature:
     // VK_KHR_driver_properties or Vulkan 1.2
     const char* fDriverPropertiesExtension = nullptr;

package/cpp/skia/{modules/pathops/include → include/pathops}/SkPathOps.h

@@ -12,8 +12,9 @@
 #include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTDArray.h"
 
-struct SkRect;
+#include <optional>
 
+struct SkRect;
 
 // FIXME: move everything below into the SkPath class
 /**
@@ -43,21 +44,35 @@ enum SkPathOp {
                   inputs.
     @return True if the operation succeeded.
   */
-bool SK_API Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result);
+std::optional<SkPath> SK_API Op(const SkPath& one, const SkPath& two, SkPathOp op);
 
-/** Set this path to a set of non-overlapping contours that describe the
+// DEPRECATED
+static inline bool Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result) {
+    if (auto res = Op(one, two, op)) {
+        *result = *res;
+        return true;
+    }
+    return false;
+}
+
+/** Return a path with a set of non-overlapping contours that describe the
     same area as the original path.
     The curve order is reduced where possible so that cubics may
     be turned into quadratics, and quadratics maybe turned into lines.
 
-    Returns true if operation was able to produce a result;
-    otherwise, result is unmodified.
-
     @param path The path to simplify.
-    @param result The simplified path. The result may be the input.
-    @return True if simplification succeeded.
+    @return The simplified path, or {} on failure.
   */
-bool SK_API Simplify(const SkPath& path, SkPath* result);
+std::optional<SkPath> SK_API Simplify(const SkPath& path);
+
+// DEPRECATED
+static inline bool Simplify(const SkPath& path, SkPath* result) {
+    if (auto res = Simplify(path)) {
+        *result = *res;
+        return true;
+    }
+    return false;
+}
 
 /** Set the resulting rectangle to the tight bounds of the path.
 
@@ -75,19 +90,25 @@ static inline bool TightBounds(const SkPath& path, SkRect* result) {
     return false;
 }
 
-/** Set the result with fill type winding to area equivalent to path.
-    Returns true if successful. Does not detect if path contains contours which
+/** Returns a path with fill type winding to area equivalent to the input.
+    Does not detect if path contains contours which
     contain self-crossings or cross other contours; in these cases, may return
-    true even though result does not fill same area as path.
+    a result even though it does not fill same area as the input.
 
-    Returns true if operation was able to produce a result;
-    otherwise, result is unmodified. The result may be the input.
+    If it fails to compute a result, returns {}.
 
     @param path The path typically with fill type set to even odd.
-    @param result The equivalent path with fill type set to winding.
-    @return True if winding path was set.
   */
-bool SK_API AsWinding(const SkPath& path, SkPath* result);
+std::optional<SkPath> SK_API AsWinding(const SkPath& path);
+
+// DEPRECATED
+static inline bool AsWinding(const SkPath& path, SkPath* result) {
+    if (auto res = AsWinding(path)) {
+        *result = *res;
+        return true;
+    }
+    return false;
+}
 
 /** Perform a series of path operations, optimized for unioning many paths together.
   */
@@ -104,10 +125,18 @@ public:
     /** Computes the sum of all paths and operands, and resets the builder to its
         initial state.
 
-        @param result The product of the operands.
-        @return True if the operation succeeded.
+        @return result The product of the operands, {} on failure.
       */
-    bool resolve(SkPath* result);
+    std::optional<SkPath> resolve();
+
+    // DEPRECATED
+    bool resolve(SkPath* result) {
+        if (auto res = this->resolve()) {
+            *result = *res;
+            return true;
+        }
+        return false;
+    }
 
 private:
     skia_private::TArray<SkPath> fPathRefs;

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

@@ -11,12 +11,13 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
 
+#include <memory>
+
 class SkFontMgr;
 class SkFontConfigInterface;
 class SkFontScanner;
 
 /** Creates a SkFontMgr which wraps a SkFontConfigInterface. */
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci);
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci,
                                           std::unique_ptr<SkFontScanner> scanner);
 

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

@@ -43,10 +43,6 @@ struct SkFontMgr_Android_CustomFonts {
 };
 
 /** Create a font manager for Android. If 'custom' is NULL, use only system fonts. */
-
-// Deprecated
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom);
-
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom,
                                               std::unique_ptr<SkFontScanner> scanner);
 #endif // SkFontMgr_android_DEFINED

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

@@ -16,9 +16,11 @@
 class SkFontMgr;
 class SkFontScanner;
 
-/** Create a font manager for Android NDK. May return nullptr if unavailable (API < 29). */
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles);
+/** Create a font manager for Android NDK. May return nullptr if unavailable (API < 29).
 
+    The Android NDK Font API only works correctly in an Android Application process.
+    If running in a bare executable (for testing or the like) it will use the legacy fonts.xml data.
+ */
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles,
                                                  std::unique_ptr<SkFontScanner> scanner);
 

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

@@ -21,7 +21,4 @@ class SkFontMgr;
 class SkFontScanner;
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc, std::unique_ptr<SkFontScanner> scanner);
 
-#if !defined(SK_DISABLE_LEGACY_FONTCONFIG_FACTORY)
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc);
-#endif
 #endif // #ifndef SkFontMgr_fontconfig_DEFINED

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

@@ -15,11 +15,13 @@
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
+#include "include/private/SkHdrMetadata.h"
 #include "include/private/base/SkTo.h"
 #include "modules/skcms/skcms.h"
 
 #include <cstdint>
 #include <memory>
+#include <tuple>
 #include <utility>
 
 struct SkEncodedInfo {
@@ -118,61 +120,27 @@ public:
     static SkEncodedInfo Make(int width, int height, Color color,
             Alpha alpha, int bitsPerComponent, std::unique_ptr<ICCProfile> profile,
             int colorDepth) {
+        return Make(width, height, color, alpha, bitsPerComponent, colorDepth, std::move(profile),
+                    skhdr::Metadata::MakeEmpty());
+    }
+
+    static SkEncodedInfo Make(int width, int height, Color color,
+            Alpha alpha, int bitsPerComponent, int colorDepth, std::unique_ptr<ICCProfile> profile,
+            const skhdr::Metadata& hdrMetadata) {
         SkASSERT(1 == bitsPerComponent ||
                  2 == bitsPerComponent ||
                  4 == bitsPerComponent ||
                  8 == bitsPerComponent ||
                  16 == bitsPerComponent);
-
-        switch (color) {
-            case kGray_Color:
-                SkASSERT(kOpaque_Alpha == alpha);
-                break;
-            case kGrayAlpha_Color:
-                SkASSERT(kOpaque_Alpha != alpha);
-                break;
-            case kPalette_Color:
-                SkASSERT(16 != bitsPerComponent);
-                break;
-            case kRGB_Color:
-            case kBGR_Color:
-            case kBGRX_Color:
-                SkASSERT(kOpaque_Alpha == alpha);
-                SkASSERT(bitsPerComponent >= 8);
-                break;
-            case kYUV_Color:
-            case kInvertedCMYK_Color:
-            case kYCCK_Color:
-                SkASSERT(kOpaque_Alpha == alpha);
-                SkASSERT(8 == bitsPerComponent);
-                break;
-            case kRGBA_Color:
-                SkASSERT(bitsPerComponent >= 8);
-                break;
-            case kBGRA_Color:
-            case kYUVA_Color:
-                SkASSERT(8 == bitsPerComponent);
-                break;
-            case kXAlpha_Color:
-                SkASSERT(kUnpremul_Alpha == alpha);
-                SkASSERT(8 == bitsPerComponent);
-                break;
-            case k565_Color:
-                SkASSERT(kOpaque_Alpha == alpha);
-                SkASSERT(8 == bitsPerComponent);
-                break;
-            default:
-                SkASSERT(false);
-                break;
-        }
-
+        VerifyColor(color, alpha, bitsPerComponent);
         return SkEncodedInfo(width,
                              height,
                              color,
                              alpha,
                              SkToU8(bitsPerComponent),
                              SkToU8(colorDepth),
-                             std::move(profile));
+                             std::move(profile),
+                             hdrMetadata);
     }
 
     /*
@@ -232,10 +200,9 @@ public:
             case kInvertedCMYK_Color:
             case kYCCK_Color:
                 return 4 * fBitsPerComponent;
-            default:
-                SkASSERT(false);
-                return 0;
         }
+        SkASSERT(false);
+        return 0;
     }
 
     SkEncodedInfo(const SkEncodedInfo& orig) = delete;
@@ -246,12 +213,9 @@ public:
 
     // Explicit copy method, to avoid accidental copying.
     SkEncodedInfo copy() const {
-        auto copy = SkEncodedInfo::Make(
-                fWidth, fHeight, fColor, fAlpha, fBitsPerComponent, nullptr, fColorDepth);
-        if (fProfile) {
-            copy.fProfile = std::make_unique<ICCProfile>(*fProfile);
-        }
-        return copy;
+        return SkEncodedInfo(
+                fWidth, fHeight, fColor, fAlpha, fBitsPerComponent, fColorDepth,
+                fProfile ? std::make_unique<ICCProfile>(*fProfile) : nullptr, fHdrMetadata);
     }
 
     // Return number of bits of R/G/B channel
@@ -259,9 +223,16 @@ public:
         return fColorDepth;
     }
 
+    // Return the HDR metadata associated with this image. Note that even SDR images can include
+    // HDR metadata (e.g, indicating how to inverse tone map when displayed on an HDR display).
+    const skhdr::Metadata& getHdrMetadata() const {
+        return fHdrMetadata;
+    }
+
 private:
     SkEncodedInfo(int width, int height, Color color, Alpha alpha,
-            uint8_t bitsPerComponent, uint8_t colorDepth, std::unique_ptr<ICCProfile> profile)
+            uint8_t bitsPerComponent, uint8_t colorDepth, std::unique_ptr<ICCProfile> profile,
+            const skhdr::Metadata& hdrMetadata)
         : fWidth(width)
         , fHeight(height)
         , fColor(color)
@@ -269,8 +240,55 @@ private:
         , fBitsPerComponent(bitsPerComponent)
         , fColorDepth(colorDepth)
         , fProfile(std::move(profile))
+        , fHdrMetadata(hdrMetadata)
     {}
 
+    static void VerifyColor(Color color, Alpha alpha, int bitsPerComponent) {
+        // Avoid `-Wunused-parameter` warnings on non-debug builds.
+        std::ignore = alpha;
+        std::ignore = bitsPerComponent;
+
+        switch (color) {
+            case kGray_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                return;
+            case kGrayAlpha_Color:
+                SkASSERT(kOpaque_Alpha != alpha);
+                return;
+            case kPalette_Color:
+                SkASSERT(16 != bitsPerComponent);
+                return;
+            case kRGB_Color:
+            case kBGR_Color:
+            case kBGRX_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(bitsPerComponent >= 8);
+                return;
+            case kYUV_Color:
+            case kInvertedCMYK_Color:
+            case kYCCK_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case kRGBA_Color:
+                SkASSERT(bitsPerComponent >= 8);
+                return;
+            case kBGRA_Color:
+            case kYUVA_Color:
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case kXAlpha_Color:
+                SkASSERT(kUnpremul_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+            case k565_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
+                SkASSERT(8 == bitsPerComponent);
+                return;
+        }
+        SkASSERT(false);  // Unrecognized `color` enum value.
+    }
+
     int                         fWidth;
     int                         fHeight;
     Color                       fColor;
@@ -278,6 +296,7 @@ private:
     uint8_t                     fBitsPerComponent;
     uint8_t                     fColorDepth;
     std::unique_ptr<ICCProfile> fProfile;
+    skhdr::Metadata             fHdrMetadata;
 };
 
 #endif

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

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkHdrMetadata_DEFINED
+#define SkHdrMetadata_DEFINED
+
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <optional>
+
+
+class SkData;
+class SkString;
+
+namespace skhdr {
+
+/**
+ * Content light level metadata.
+ * The semantics of this metadata is defined in:
+ *   ANSI/CTA-861-H A DTV Profile for Uncompressed High Speed Digital Interfaces
+ *   Annex P Calculation of MaxCLL and MaxFALL
+ * Slightly different semantics for this metadata are defined in:
+ *   Portable Network Graphics (PNG) Specification (Third Edition)
+ *   11.3.2.8 cLLI Content Light Level Information
+ *   https://www.w3.org/TR/png-3/#cLLI-chunk
+ * This metadata should only be used in ways that work with both semantics.
+ */
+struct SK_API ContentLightLevelInformation {
+    float fMaxCLL = 0.f;
+    float fMaxFALL = 0.f;
+
+    /**
+     * Decode from the binary encoding listed at:
+     *   AV1 Bitstream & Decoding Process Specification Version 1.0.0 Errata 1
+     *   https://aomediacodec.github.io/av1-spec/av1-spec.pdf
+     *   5.8.3 Metadata high dynamic range content light level syntax
+     * This encoding is equivalent to:
+     *   ITU-T H.265 (V10) (07/2024)
+     *   D.2.35 Content light level information SEI message syntax
+     * Return false if parsing fails.
+     */
+    bool parse(const SkData* data);
+
+    /**
+     * Serialize to the encoding used by parse().
+     */
+    sk_sp<SkData> serialize() const;
+
+    /**
+     * Decode from the binary encoding listed at:
+     *   Portable Network Graphics (PNG) Specification (Third Edition)
+     *   11.3.2.8 cLLI Content Light Level Information
+     *   https://www.w3.org/TR/png-3/#cLLI-chunk
+     * This encoding is not equivalent to the encoding used by parse().
+     * Return false if parsing fails.
+     */
+    bool parsePngChunk(const SkData* data);
+
+    /**
+     * Serialize to the encoding used by parsePngChunk().
+     */
+    sk_sp<SkData> serializePngChunk() const;
+
+    /**
+     * Return a human-readable description.
+     */
+    SkString toString() const;
+
+    bool operator==(const ContentLightLevelInformation& other) const;
+    bool operator!=(const ContentLightLevelInformation& other) const {
+        return !(*this == other);
+    }
+};
+
+/**
+ * Mastering display color volume metadata.
+ * The semantics of this metadata is defined in:
+ * SMPTE ST 2086:2018 Mastering Display Color Volume Metadata Supporting
+ * High Luminance and Wide Color Gamut Images
+ */
+struct SK_API MasteringDisplayColorVolume {
+    SkColorSpacePrimaries fDisplayPrimaries = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+    float fMaximumDisplayMasteringLuminance = 0.f;
+    float fMinimumDisplayMasteringLuminance = 0.f;
+
+    /**
+     * The encoding as defined in:
+     *   AV1 Bitstream & Decoding Process Specification Version 1.0.0 Errata 1
+     *   https://aomediacodec.github.io/av1-spec/av1-spec.pdf
+     *   5.8.4 Metadata high dynamic range mastering display color volume syntax
+     * This encoding is equivalent to:
+     *   ITU-T H.265 (V10) (07/2024)
+     *   D.2.35 Content light level information SEI message syntax
+     * This encoding is also equivalent to:
+     *   Portable Network Graphics (PNG) Specification (Third Edition)
+     *   11.3.2.7 mDCV Mastering Display Color Volume
+     *   https://www.w3.org/TR/png-3/#mDCV-chunk
+     * Return false if parsing fails.
+     */
+    bool parse(const SkData* data);
+
+    /**
+     * Serialize to the encoding used by parse().
+     */
+    sk_sp<SkData> serialize() const;
+
+    /**
+     * Return a human-readable description.
+     */
+    SkString toString() const;
+
+    bool operator==(const MasteringDisplayColorVolume& other) const;
+    bool operator!=(const MasteringDisplayColorVolume& other) const {
+        return !(*this == other);
+    }
+};
+
+/**
+ * Structure containing all HDR metadata that can be attached to an image or video frame.
+ */
+class SK_API Metadata {
+  public:
+    /**
+     * Return a container with no metadata.
+     */
+    static Metadata MakeEmpty();
+
+    /**
+     * If there does not exists Content Light Level Information metadata, then return false.
+     * Otherwise return true and if `clli` is non-nullptr then write the metadata to `clli`.
+     */
+    bool getContentLightLevelInformation(ContentLightLevelInformation* clli) const;
+
+    /**
+     * Set the Content Light Level Information metadata.
+     */
+    void setContentLightLevelInformation(const ContentLightLevelInformation& clli);
+
+    /**
+     * If there does not exists Mastering Display Color Volume metadata, then return false.
+     * Otherwise return true and if `mdcv` is non-nullptr then write the metadata to `mdcv`.
+     */
+    bool getMasteringDisplayColorVolume(MasteringDisplayColorVolume* mdcv) const;
+
+    /**
+     * Set the Mastering Display Color Volume metadata.
+     */
+    void setMasteringDisplayColorVolume(const MasteringDisplayColorVolume& mdcv);
+
+    /**
+     * Return a human-readable description.
+     */
+    SkString toString() const;
+
+    bool operator==(const Metadata& other) const;
+    bool operator!=(const Metadata& other) const {
+      return !(*this == other);
+    }
+
+  private:
+    std::optional<ContentLightLevelInformation> fContentLightLevelInformation;
+    std::optional<MasteringDisplayColorVolume> fMasteringDisplayColorVolume;
+};
+
+}  // namespace skhdr
+
+#endif