rngine 0.7.2 → 0.8.1

package/shared/skia/include/private/SkGainmapShader.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkGainmapShader_DEFINED
+#define SkGainmapShader_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkColorSpace;
+class SkShader;
+class SkImage;
+struct SkGainmapInfo;
+struct SkRect;
+struct SkSamplingOptions;
+
+/**
+ *  A gainmap shader will apply a gainmap to an base image using the math described alongside the
+ *  definition of SkGainmapInfo.
+ */
+class SK_API SkGainmapShader {
+public:
+    /**
+     *  Make a gainmap shader.
+     *
+     *  When sampling the base image baseImage, the rectangle baseRect will be sampled to map to
+     *  the rectangle dstRect. Sampling will be done according to baseSamplingOptions.
+     *
+     *  When sampling the gainmap image gainmapImage, the rectangle gainmapRect will be sampled to
+     *  map to the rectangle dstRect. Sampling will be done according to gainmapSamplingOptions.
+     *
+     *  The gainmap will be applied according to the HDR to SDR ratio specified in dstHdrRatio.
+     */
+    static sk_sp<SkShader> Make(const sk_sp<const SkImage>& baseImage,
+                                const SkRect& baseRect,
+                                const SkSamplingOptions& baseSamplingOptions,
+                                const sk_sp<const SkImage>& gainmapImage,
+                                const SkRect& gainmapRect,
+                                const SkSamplingOptions& gainmapSamplingOptions,
+                                const SkGainmapInfo& gainmapInfo,
+                                const SkRect& dstRect,
+                                float dstHdrRatio);
+
+    static sk_sp<SkShader> Make(const sk_sp<const SkImage>& baseImage,
+                                const SkRect& baseRect,
+                                const SkSamplingOptions& baseSamplingOptions,
+                                const sk_sp<const SkImage>& gainmapImage,
+                                const SkRect& gainmapRect,
+                                const SkSamplingOptions& gainmapSamplingOptions,
+                                const SkGainmapInfo& gainmapInfo,
+                                const SkRect& dstRect,
+                                float dstHdrRatio,
+                                sk_sp<SkColorSpace> dstColorSpace);
+};
+
+#endif

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

@@ -0,0 +1,357 @@
+/*
+ * 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/SkData.h"
+#include "include/private/SkAPI.h"
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <optional>
+#include <vector>
+
+class SkColorFilter;
+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;
+
+    /**
+     * Helper functions for accessing members as uint16_t, which is often needed when interacting
+     * with libraries using the CTA semantics.
+     */
+    static ContentLightLevelInformation MakeUint16(uint16_t maxCLL, uint16_t maxFALL) {
+        return { .fMaxCLL = static_cast<float>(maxCLL), .fMaxFALL = static_cast<float>(maxFALL) };
+    }
+    uint16_t getUint16MaxCLL() const {
+        return static_cast<uint16_t>(std::clamp(std::round(fMaxCLL), 0.f, 65535.f));
+    }
+    uint16_t getUint16MaxFALL() const {
+        return static_cast<uint16_t>(std::clamp(std::round(fMaxFALL), 0.f, 65535.f));
+    }
+
+    /**
+     * 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);
+    }
+};
+
+/**
+ * Adaptive Global Tone Map
+ * This structure contains the metadata items from the ColorVolumeTransform metadata group
+ * in Clause 7.1: Metadata set of SMPTE ST 2094-50: Dynamic metadata for color volume transform
+ * Application #5
+ * https://github.com/SMPTE/st2094-50
+ * WARNING: This specification is still a DRAFT and is subject to change before publication.
+ */
+struct SK_API AdaptiveGlobalToneMap {
+    // A GainCurve metadata group.
+    struct SK_API GainCurve {
+        // Structure holding one entry of the GainCurveControlPointX, GainCurveControlPointY, and
+        // GainCurveControlPointM metadata items.
+        struct ControlPoint {
+            float fX = 0.f;
+            float fY = 0.f;
+            float fM = 0.f;
+
+            bool operator==(const ControlPoint& other) const {
+                return fX == other.fX && fY == other.fY && fM == other.fM;
+            }
+        };
+
+        // The size of this vector is the value of the GainCurveNumControlPoints metadata item.
+        static constexpr size_t kMinNumControlPoints = 1u;
+        static constexpr size_t kMaxNumControlPoints = 32u;
+        std::vector<ControlPoint> fControlPoints = {};
+
+        bool operator==(const GainCurve& other) const {
+            return fControlPoints == other.fControlPoints;
+        }
+    };
+
+    // A ComponentMix metadata group.
+    struct SK_API ComponentMixingFunction {
+        // The ComponentMixRed/Green/Blue/Max/Min/Component metadata items.
+        float fRed = 0.f;
+        float fGreen = 0.f;
+        float fBlue = 0.f;
+        float fMax = 0.f;
+        float fMin = 0.f;
+        float fComponent = 0.f;
+
+        bool operator==(const ComponentMixingFunction& other) const {
+            return fRed == other.fRed && fGreen == other.fGreen && fBlue == other.fBlue &&
+                   fMax == other.fMax && fMin == other.fMin && fComponent == other.fComponent;
+        }
+    };
+
+    // A ColorGainFunction metadata group.
+    struct SK_API ColorGainFunction {
+        // The ComponentMix metadata group.
+        ComponentMixingFunction fComponentMixing = {};
+
+        // The GainCurve metadata group.
+        GainCurve fGainCurve = {};
+
+        bool operator==(const ColorGainFunction& other) const {
+            return fComponentMixing == other.fComponentMixing && fGainCurve == other.fGainCurve;
+        }
+    };
+
+    // Structure holding the metadata items and groups for an alternate image.
+    struct SK_API AlternateImage {
+        // The AlternateHdrHeadroom metadata item.
+        float fHdrHeadroom = 0.f;
+
+        // The ColorGainFunction metadata group.
+        ColorGainFunction fColorGainFunction = {};
+
+        bool operator==(const AlternateImage& other) const {
+            return fHdrHeadroom == other.fHdrHeadroom && fColorGainFunction == other.fColorGainFunction;
+        }
+    };
+
+    // HeadroomAdaptiveToneMap metadata group.
+    struct SK_API HeadroomAdaptiveToneMap {
+        // The BaselineHdrHeadroom metadata item.
+        float fBaselineHdrHeadroom = 0.f;
+
+        // The GainApplicationSpaceColorPrimaries metadata item.
+        SkColorSpacePrimaries fGainApplicationSpacePrimaries =
+            {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+        // The size of this vector is the NumAlternateImages metadata item.
+        static constexpr size_t kMaxNumAlternateImages = 4u;
+        std::vector<AlternateImage> fAlternateImages = {};
+
+        bool operator==(const HeadroomAdaptiveToneMap& other) const {
+            return fBaselineHdrHeadroom == other.fBaselineHdrHeadroom &&
+                   fGainApplicationSpacePrimaries == other.fGainApplicationSpacePrimaries &&
+                   fAlternateImages == other.fAlternateImages;
+        }
+    };
+
+    // The default value for the HdrReferenceWhite metadata item.
+    static constexpr float kDefaultHdrReferenceWhite = 203.f;
+
+    // The HdrReferenceWhite metadata item.
+    float fHdrReferenceWhite = kDefaultHdrReferenceWhite;
+
+    // The HeadroomAdaptiveToneMap metadata group.
+    std::optional<HeadroomAdaptiveToneMap> fHeadroomAdaptiveToneMap = std::nullopt;
+
+    /**
+     * Decode from the binary encoding in Annex C.
+     */
+    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;
+
+    /**
+     * Return true if this metadata satisfies all normative constraints.
+     */
+    bool isValid() const;
+
+    bool operator==(const AdaptiveGlobalToneMap& other) const {
+        return fHdrReferenceWhite == other.fHdrReferenceWhite &&
+               fHeadroomAdaptiveToneMap == other.fHeadroomAdaptiveToneMap;
+    }
+};
+
+/**
+ * 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);
+
+    /**
+     * If there does not exists Adaptive Global Tone Map metadata, then return false.
+     * Otherwise return true and if `agtm` is non-nullptr then write the metadata to `agtm`.
+     */
+    bool getAdaptiveGlobalToneMap(AdaptiveGlobalToneMap* agtm) const;
+
+    /**
+     * Set the Adaptive Global Tone Map metadata.
+     */
+    void setAdaptiveGlobalToneMap(const AdaptiveGlobalToneMap& agtm);
+
+    /**
+     * Return the serialized Adaptive Global Tone Mapping metadata, or nullptr if none has been set.
+     */
+    sk_sp<const SkData> getSerializedAgtm() const;
+
+    /**
+     * Set the serialized Adaptive Global Tone Mapping metadata.
+     */
+    void setSerializedAgtm(sk_sp<const SkData>);
+
+    /**
+     * Return a human-readable description.
+     */
+    SkString toString() const;
+
+    /**
+     * Return the SkColorFilter to tone map to the specified targeted HDR headroom.
+     *
+     * The `inputColorSpace` parameter is the color space of the input image that will be
+     * used with the image. If it is PQ or HLG, then the color filter will effectively
+     * reinterpret the image as having the HDR reference white parameter indicated in the
+     * metadata.
+     *
+     * If `inputColorSpace` is PQ or HLG, then a default tone mapping will be provided,
+     * inferring the baseline HDR headroom from the CLLI or MDCV metadata, if present.
+     */
+    sk_sp<SkColorFilter> makeToneMapColorFilter(
+        float targetedHdrHeadroom, const SkColorSpace* inputColorSpace = nullptr) 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;
+    std::optional<AdaptiveGlobalToneMap> fAdaptiveGlobalToneMap;
+};
+
+}  // namespace skhdr
+
+#endif

package/shared/skia/include/private/SkIDChangeListener.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkIDChangeListener_DEFINED
+#define SkIDChangeListener_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkMutex.h"
+#include "include/private/SkTArray.h"
+#include "include/private/SkThreadAnnotations.h"
+
+#include <atomic>
+
+/**
+ * Used to be notified when a gen/unique ID is invalidated, typically to preemptively purge
+ * associated items from a cache that are no longer reachable. The listener can
+ * be marked for deregistration if the cached item is remove before the listener is
+ * triggered. This prevents unbounded listener growth when cache items are routinely
+ * removed before the gen ID/unique ID is invalidated.
+ */
+class SkIDChangeListener : public SkRefCnt {
+public:
+    SkIDChangeListener();
+
+    ~SkIDChangeListener() override;
+
+    virtual void changed() = 0;
+
+    /**
+     * Mark the listener is no longer needed. It should be removed and changed() should not be
+     * called.
+     */
+    void markShouldDeregister() { fShouldDeregister.store(true, std::memory_order_relaxed); }
+
+    /** Indicates whether markShouldDeregister was called. */
+    bool shouldDeregister() { return fShouldDeregister.load(std::memory_order_acquire); }
+
+    /** Manages a list of SkIDChangeListeners. */
+    class List {
+    public:
+        List();
+
+        ~List();
+
+        /**
+         * Add a new listener to the list. It must not already be deregistered. Also clears out
+         * previously deregistered listeners.
+         */
+        void add(sk_sp<SkIDChangeListener> listener) SK_EXCLUDES(fMutex);
+
+        /**
+         * The number of registered listeners (including deregisterd listeners that are yet-to-be
+         * removed.
+         */
+        int count() const SK_EXCLUDES(fMutex);
+
+        /** Calls changed() on all listeners that haven't been deregistered and resets the list. */
+        void changed() SK_EXCLUDES(fMutex);
+
+        /** Resets without calling changed() on the listeners. */
+        void reset() SK_EXCLUDES(fMutex);
+
+    private:
+        mutable SkMutex fMutex;
+        skia_private::STArray<1, sk_sp<SkIDChangeListener>> fListeners SK_GUARDED_BY(fMutex);
+    };
+
+private:
+    std::atomic<bool> fShouldDeregister;
+};
+
+#endif

package/shared/skia/include/private/SkJpegGainmapEncoder.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegGainmapEncoder_DEFINED
+#define SkJpegGainmapEncoder_DEFINED
+
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+struct SkGainmapInfo;
+
+class SK_API SkJpegGainmapEncoder {
+public:
+    /**
+     *  Encode an UltraHDR image to |dst|.
+     *
+     *  The base image is specified by |base|, and |baseOptions| controls the encoding behavior for
+     *  the base image.
+     *
+     *  The gainmap image is specified by |gainmap|, and |gainmapOptions| controls the encoding
+     *  behavior for the gainmap image.
+     *
+     *  The rendering behavior of the gainmap image is provided in |gainmapInfo|.
+     *
+     *  If |baseOptions| or |gainmapOptions| specify XMP metadata, then that metadata will be
+     *  overwritten.
+     *
+     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+     */
+    static bool EncodeHDRGM(SkWStream* dst,
+                            const SkPixmap& base,
+                            const SkJpegEncoder::Options& baseOptions,
+                            const SkPixmap& gainmap,
+                            const SkJpegEncoder::Options& gainmapOptions,
+                            const SkGainmapInfo& gainmapInfo);
+
+    /**
+     *  Write a Multi Picture Format containing the |imageCount| images specified by |images|.
+     */
+    static bool MakeMPF(SkWStream* dst, const SkData** images, size_t imageCount);
+};
+
+#endif

package/shared/skia/include/private/SkJpegMetadataDecoder.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkJpegMetadataDecoder_DEFINED
+#define SkJpegMetadataDecoder_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+#include <vector>
+
+struct SkGainmapInfo;
+
+/**
+ * An interface that can be used to extract metadata from an encoded JPEG file.
+ */
+class SK_API SkJpegMetadataDecoder {
+public:
+    SkJpegMetadataDecoder() {}
+    virtual ~SkJpegMetadataDecoder() {}
+
+    SkJpegMetadataDecoder(const SkJpegMetadataDecoder&) = delete;
+    SkJpegMetadataDecoder& operator=(const SkJpegMetadataDecoder&) = delete;
+
+    /**
+     * A segment from a JPEG file. This is usually populated from a jpeg_marker_struct.
+     */
+    struct SK_API Segment {
+        Segment(uint8_t marker, sk_sp<const SkData> data)
+                : fMarker(marker), fData(std::move(data)) {}
+
+        // The segment's marker.
+        uint8_t fMarker = 0;
+
+        // The segment's parameters (not including the marker and parameter length).
+        sk_sp<const SkData> fData;
+    };
+
+    /**
+     * Create metadata for the specified segments from a JPEG file's header (defined as all segments
+     * before the first StartOfScan). This may return nullptr.
+     */
+    static std::unique_ptr<SkJpegMetadataDecoder> Make(std::vector<Segment> headerSegments);
+
+    /**
+     * Create metadata for the specified encoded JPEG file. This may return nullptr.
+     */
+    static std::unique_ptr<SkJpegMetadataDecoder> Make(sk_sp<const SkData> data);
+
+    /**
+     * Return the Exif data attached to the image (if any) and nullptr otherwise. If |copyData| is
+     * false, then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<const SkData> getExifMetadata(bool copyData) const = 0;
+
+    /**
+     * Return the ICC profile of the image if any, and nullptr otherwise. If |copyData| is false,
+     * then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<const SkData> getICCProfileData(bool copyData) const = 0;
+
+    /**
+     * Return the ISO 21496-1 metadata, if any, and nullptr otherwise. If |copyData| is false,
+     * then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<const SkData> getISOGainmapMetadata(bool copyData) const = 0;
+
+    /**
+     * Return true if there is a possibility that this image contains a gainmap image.
+     */
+    virtual bool mightHaveGainmapImage() const = 0;
+
+    /**
+     * Given a JPEG encoded image |baseImageData|, return in |outGainmapImageData| the JPEG encoded
+     * gainmap image and return in |outGainmapInfo| its gainmap rendering parameters. Return true if
+     * both output variables were successfully populated, otherwise return false.
+     */
+    virtual std::pair<sk_sp<const SkData>, SkGainmapInfo> findGainmapImage(
+            sk_sp<const SkData>) const = 0;
+
+    // deprecated
+    virtual bool findGainmapImage(sk_sp<const SkData> baseImageData,
+                                  sk_sp<SkData>& outGainmapImagedata,
+                                  SkGainmapInfo& outGainmapInfo) = 0;
+
+    /**
+     * Return the first JUMBF superbox, if any, and nullptr otherwise. If |copyData| is false,
+     * then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<const SkData> getJUMBFMetadata(bool copyData) const = 0;
+};
+
+#endif