rngine 0.8.0 → 0.8.2

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

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFeatures_DEFINED
+#define SkFeatures_DEFINED
+
+#if !defined(SK_BUILD_FOR_ANDROID) && !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_WIN) && \
+    !defined(SK_BUILD_FOR_UNIX) && !defined(SK_BUILD_FOR_MAC)
+
+    #ifdef __APPLE__
+        #include <TargetConditionals.h>
+    #endif
+
+    #if defined(_WIN32) || defined(__SYMBIAN32__)
+        #define SK_BUILD_FOR_WIN
+    #elif defined(ANDROID) || defined(__ANDROID__)
+        #define SK_BUILD_FOR_ANDROID
+    #elif defined(__EMSCRIPTEN__)
+        // WASM toolchains expose a Unix-like compilation environment, but it is
+        // not Unix (e.g. posix signals are not supported).
+        #define SK_BUILD_FOR_WASM
+    #elif defined(linux) || defined(__linux) || defined(__FreeBSD__) || \
+          defined(__OpenBSD__) || defined(__sun) || defined(__NetBSD__) || \
+          defined(__DragonFly__) || defined(__Fuchsia__) || \
+          defined(__GLIBC__) || defined(__GNU__) || defined(__unix__)
+        #define SK_BUILD_FOR_UNIX
+    #elif TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+        #define SK_BUILD_FOR_IOS
+    #else
+        #define SK_BUILD_FOR_MAC
+    #endif
+#endif // end SK_BUILD_FOR_*
+
+
+#if defined(SK_BUILD_FOR_WIN) && !defined(__clang__)
+    #if !defined(SK_RESTRICT)
+        #define SK_RESTRICT __restrict
+    #endif
+#endif
+
+#if !defined(SK_RESTRICT)
+    #define SK_RESTRICT __restrict__
+#endif
+
+#if !defined(SK_CPU_BENDIAN) && !defined(SK_CPU_LENDIAN)
+    #if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+        #define SK_CPU_BENDIAN
+    #elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+        #define SK_CPU_LENDIAN
+    #elif defined(__sparc) || defined(__sparc__) || \
+      defined(_POWER) || defined(__powerpc__) || \
+      defined(__ppc__) || defined(__hppa) || \
+      defined(__PPC__) || defined(__PPC64__) || \
+      defined(_MIPSEB) || defined(__ARMEB__) || \
+      defined(__s390__) || \
+      (defined(__sh__) && defined(__BIG_ENDIAN__)) || \
+      (defined(__ia64) && defined(__BIG_ENDIAN__))
+         #define SK_CPU_BENDIAN
+    #else
+        #define SK_CPU_LENDIAN
+    #endif
+#endif
+
+#if defined(__i386) || defined(_M_IX86) ||  defined(__x86_64__) || defined(_M_X64)
+  #define SK_CPU_X86 1
+#endif
+
+#if defined(__loongarch__) || defined (__loongarch64)
+  #define SK_CPU_LOONGARCH 1
+#endif
+
+#if defined(__powerpc__) || defined (__powerpc64__)
+  #define SK_CPU_PPC 1
+#endif
+
+/**
+ *  SK_CPU_X64_LEVEL
+ *
+ *  If defined, SK_CPU_X64_LEVEL should be set to the highest supported level.
+ *  On non-Intel, non-AMD CPUs this should be undefined.
+ */
+#define SK_CPU_X64_LEVEL_SSE1     10
+#define SK_CPU_X64_LEVEL_SSE2     20
+#define SK_CPU_X64_LEVEL_SSE3     30
+#define SK_CPU_X64_LEVEL_SSSE3    31
+#define SK_CPU_X64_LEVEL_SSE41    41
+#define SK_CPU_X64_LEVEL_SSE42    42
+#define SK_CPU_X64_LEVEL_AVX      51
+#define SK_CPU_X64_LEVEL_AVX2     52
+#define SK_CPU_X64_LEVEL_ML4      60
+
+/**
+ *  SK_CPU_LSX_LEVEL
+ *
+ *  If defined, SK_CPU_LSX_LEVEL should be set to the highest supported level.
+ *  On non-loongarch CPU this should be undefined.
+ */
+#define SK_CPU_LSX_LEVEL_LSX      10
+#define SK_CPU_LSX_LEVEL_LASX     20
+
+// TODO(kjlubick) clean up these checks
+
+// Are we in GCC/Clang?
+#ifndef SK_CPU_X64_LEVEL
+    // These checks must be done in descending order to ensure we set the highest
+    // available SSE level.
+    #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
+        defined(__AVX512BW__) && defined(__AVX512VL__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_ML4
+    #elif defined(__AVX2__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_AVX2
+    #elif defined(__AVX__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_AVX
+    #elif defined(__SSE4_2__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE42
+    #elif defined(__SSE4_1__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE41
+    #elif defined(__SSSE3__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSSE3
+    #elif defined(__SSE3__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE3
+    #elif defined(__SSE2__)
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE2
+    #endif
+#endif
+
+#ifndef SK_CPU_LSX_LEVEL
+    #if defined(__loongarch_asx)
+        #define SK_CPU_LSX_LEVEL    SK_CPU_LSX_LEVEL_LASX
+    #elif defined(__loongarch_sx)
+        #define SK_CPU_LSX_LEVEL    SK_CPU_LSX_LEVEL_LSX
+    #endif
+#endif
+
+// Are we in VisualStudio?
+#ifndef SK_CPU_X64_LEVEL
+    // These checks must be done in descending order to ensure we set the highest
+    // available SSE level. 64-bit intel guarantees at least SSE2 support.
+    #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
+        defined(__AVX512BW__) && defined(__AVX512VL__)
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_ML4
+    #elif defined(__AVX2__)
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_AVX2
+    #elif defined(__AVX__)
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_AVX
+    #elif defined(_M_X64) || defined(_M_AMD64)
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_SSE2
+    #elif defined(_M_IX86_FP)
+        #if _M_IX86_FP >= 2
+            #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE2
+        #elif _M_IX86_FP == 1
+            #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE1
+        #endif
+    #endif
+#endif
+
+// ARM defines
+#if defined(__arm__) && (!defined(__APPLE__) || !TARGET_IPHONE_SIMULATOR)
+    #define SK_CPU_ARM32
+#elif defined(__aarch64__)
+    #define SK_CPU_ARM64
+#endif
+
+// All 64-bit ARM chips have NEON.  Many 32-bit ARM chips do too.
+#if !defined(SK_ARM_HAS_NEON) && defined(__ARM_NEON)
+    #define SK_ARM_HAS_NEON
+#endif
+
+#endif // SkFeatures_DEFINED

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

@@ -0,0 +1,143 @@
+/*
+ * 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 SkFixed_DEFINED
+#define SkFixed_DEFINED
+
+#include "include/private/SkAssert.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkMath.h" // IWYU pragma: keep
+#include "include/private/SkTPin.h" // IWYU pragma: keep
+
+#include <cstdint>
+
+/** \file SkFixed.h
+
+    Types and macros for 16.16 fixed point
+*/
+
+/** 32 bit signed integer used to represent fractions values with 16 bits to the right of the decimal point
+*/
+typedef int32_t             SkFixed;
+#define SK_Fixed1           (1 << 16)
+#define SK_FixedHalf        (1 << 15)
+#define SK_FixedQuarter     (1 << 14)
+#define SK_FixedMax         (0x7FFFFFFF)
+#define SK_FixedMin         (-SK_FixedMax)
+#define SK_FixedPI          (0x3243F)
+#define SK_FixedSqrt2       (92682)
+#define SK_FixedTanPIOver8  (0x6A0A)
+#define SK_FixedRoot2Over2  (0xB505)
+
+// NOTE: SkFixedToFloat is exact. SkFloatToFixed seems to lack a rounding step. For all fixed-point
+// values, this version is as accurate as possible for (fixed -> float -> fixed). Rounding reduces
+// accuracy if the intermediate floats are in the range that only holds integers (adding 0.5f to an
+// odd integer then snaps to nearest even). Using double for the rounding math gives maximum
+// accuracy for (float -> fixed -> float), but that's usually overkill.
+#define SkFixedToFloat(x)   ((x) * 1.52587890625e-5f)
+#define SkFloatToFixed(x)   sk_float_saturate2int((x) * SK_Fixed1)
+
+#ifdef SK_DEBUG
+    static inline SkFixed SkFloatToFixed_Check(float x) {
+        int64_t n64 = (int64_t)(x * SK_Fixed1);
+        SkFixed n32 = (SkFixed)n64;
+        SkASSERT(n64 == n32);
+        return n32;
+    }
+#else
+    #define SkFloatToFixed_Check(x) SkFloatToFixed(x)
+#endif
+
+#define SkFixedToDouble(x)  ((x) * 1.52587890625e-5)
+#define SkDoubleToFixed(x)  ((SkFixed)((x) * SK_Fixed1))
+
+/** Converts an integer to a SkFixed, asserting that the result does not overflow
+    a 32 bit signed integer
+*/
+#ifdef SK_DEBUG
+    inline SkFixed SkIntToFixed(int n)
+    {
+        SkASSERT(n >= -32768 && n <= 32767);
+        // Left shifting a negative value has undefined behavior in C, so we cast to unsigned before
+        // shifting.
+        return (SkFixed)( (unsigned)n << 16 );
+    }
+#else
+    // Left shifting a negative value has undefined behavior in C, so we cast to unsigned before
+    // shifting. Then we force the cast to SkFixed to ensure that the answer is signed (like the
+    // debug version).
+    #define SkIntToFixed(n)     (SkFixed)((unsigned)(n) << 16)
+#endif
+
+#define SkFixedRoundToInt(x)    (((x) + SK_FixedHalf) >> 16)
+#define SkFixedCeilToInt(x)     (((x) + SK_Fixed1 - 1) >> 16)
+#define SkFixedFloorToInt(x)    ((x) >> 16)
+
+static inline SkFixed SkFixedRoundToFixed(SkFixed x) {
+    return (SkFixed)( (uint32_t)(x + SK_FixedHalf) & 0xFFFF0000 );
+}
+static inline SkFixed SkFixedCeilToFixed(SkFixed x) {
+    return (SkFixed)( (uint32_t)(x + SK_Fixed1 - 1) & 0xFFFF0000 );
+}
+static inline SkFixed SkFixedFloorToFixed(SkFixed x) {
+    return (SkFixed)( (uint32_t)x & 0xFFFF0000 );
+}
+
+#define SkFixedAve(a, b)    (((a) + (b)) >> 1)
+
+// The divide may exceed 32 bits. Clamp to a signed 32 bit result.
+#define SkFixedDiv(numer, denom) \
+    SkToS32(SkTPin<int64_t>((SkLeftShift((int64_t)(numer), 16) / (denom)), SK_MinS32, SK_MaxS32))
+
+static inline SkFixed SkFixedMul(SkFixed a, SkFixed b) {
+    return (SkFixed)((int64_t)a * b >> 16);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Platform-specific alternatives to our portable versions.
+
+// The VCVT float-to-fixed instruction is part of the VFPv3 instruction set.
+#if defined(__ARM_VFPV3__)
+    #include <cstring>
+
+    /* This does not handle NaN or other obscurities, but is faster than
+       than (int)(x*65536).  When built on Android with -Os, needs forcing
+       to inline or we lose the speed benefit.
+    */
+    SK_ALWAYS_INLINE SkFixed SkFloatToFixed_arm(float x)
+    {
+        int32_t y;
+        asm("vcvt.s32.f32 %0, %0, #16": "+w"(x));
+        std::memcpy(&y, &x, sizeof(y));
+        return y;
+    }
+    #undef SkFloatToFixed
+    #define SkFloatToFixed(x)  SkFloatToFixed_arm(x)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define SkFixedToScalar(x)          SkFixedToFloat(x)
+#define SkScalarToFixed(x)          SkFloatToFixed(x)
+
+///////////////////////////////////////////////////////////////////////////////
+
+typedef int64_t SkFixed3232;   // 32.32
+
+#define SkFixed3232Max            SK_MaxS64
+#define SkFixed3232Min            (-SkFixed3232Max)
+
+#define SkIntToFixed3232(x)       (SkLeftShift((SkFixed3232)(x), 32))
+#define SkFixed3232ToInt(x)       ((int)((x) >> 32))
+#define SkFixedToFixed3232(x)     (SkLeftShift((SkFixed3232)(x), 16))
+#define SkFixed3232ToFixed(x)     ((SkFixed)((x) >> 16))
+#define SkFloatToFixed3232(x)     sk_float_saturate2int64((x) * (65536.0f * 65536.0f))
+#define SkFixed3232ToFloat(x)     (x * (1 / (65536.0f * 65536.0f)))
+
+#define SkScalarToFixed3232(x)    SkFloatToFixed3232(x)
+
+#endif

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

@@ -0,0 +1,183 @@
+/*
+ * 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 SkFloatingPoint_DEFINED
+#define SkFloatingPoint_DEFINED
+
+#include "include/private/SkAttributes.h"
+#include "include/private/SkMath.h"
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+inline constexpr float SK_FloatSqrt2 = 1.41421356f;
+inline constexpr float SK_FloatPI    = 3.14159265f;
+inline constexpr double SK_DoublePI  = 3.14159265358979323846264338327950288;
+
+static constexpr int sk_float_sgn(float x) {
+    return (0.0f < x) - (x < 0.0f);
+}
+
+static constexpr float sk_float_degrees_to_radians(float degrees) {
+    return degrees * (SK_FloatPI / 180);
+}
+
+static constexpr float sk_float_radians_to_degrees(float radians) {
+    return radians * (180 / SK_FloatPI);
+}
+
+// floor(double+0.5) vs. floorf(float+0.5f) give comparable performance, but upcasting to double
+// means tricky values like 0.49999997 and 2^24 get rounded correctly. If these were rounded
+// as floatf(x + .5f), they would be 1 higher than expected.
+#define sk_float_round(x) (float)sk_double_round((double)(x))
+
+template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline constexpr bool SkIsNaN(T x) {
+    return x != x;
+}
+
+// Subtracting a value from itself will result in zero, except for NAN or ±Inf, which make NAN.
+// Multiplying a group of values against zero will result in zero for each product, except for
+// NAN or ±Inf, which will result in NAN and continue resulting in NAN for the rest of the elements.
+// This generates better code than `std::isfinite` when building with clang-cl (April 2024).
+template <typename T, typename... Pack, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline bool SkIsFinite(T x, Pack... values) {
+    T prod = x - x;
+    prod = (prod * ... * values);
+    // At this point, `prod` will either be NaN or 0.
+    return prod == prod;
+}
+
+template <typename T, std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
+static inline bool SkIsFinite(const T array[], int count) {
+    T x = array[0];
+    T prod = x - x;
+    for (int i = 1; i < count; ++i) {
+        prod *= array[i];
+    }
+    // At this point, `prod` will either be NaN or 0.
+    return prod == prod;
+}
+
+inline constexpr int SK_MaxS32FitsInFloat = 2147483520;
+inline constexpr int SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat;
+
+// 0x7fffff8000000000
+inline constexpr int64_t SK_MaxS64FitsInFloat = SK_MaxS64 >> (63-24) << (63-24);
+inline constexpr int64_t SK_MinS64FitsInFloat = -SK_MaxS64FitsInFloat;
+
+// sk_[float|double]_saturate2int are written to return their maximum values when passed NaN.
+// MSVC 19.38+ has a bug with this implementation, leading to incorrect results:
+// https://developercommunity.visualstudio.com/t/Optimizer-incorrectly-handles-NaN-floati/10654403
+//
+// We inject an explicit NaN test on MSVC to work around the problem.
+#if defined(_MSC_VER) && !defined(__clang__)
+    #define SK_CHECK_NAN(resultVal) if (SkIsNaN(x)) { return resultVal; }
+#else
+    #define SK_CHECK_NAN(resultVal)
+#endif
+
+/**
+ *  Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.
+ */
+static constexpr int sk_float_saturate2int(float x) {
+    SK_CHECK_NAN(SK_MaxS32FitsInFloat)
+    x = x < SK_MaxS32FitsInFloat ? x : SK_MaxS32FitsInFloat;
+    x = x > SK_MinS32FitsInFloat ? x : SK_MinS32FitsInFloat;
+    return (int)x;
+}
+
+/**
+ *  Return the closest int for the given double. Returns SK_MaxS32 for NaN.
+ */
+static constexpr int sk_double_saturate2int(double x) {
+    SK_CHECK_NAN(SK_MaxS32)
+    x = x < SK_MaxS32 ? x : SK_MaxS32;
+    x = x > SK_MinS32 ? x : SK_MinS32;
+    return (int)x;
+}
+
+/**
+ *  Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.
+ */
+static constexpr int64_t sk_float_saturate2int64(float x) {
+    SK_CHECK_NAN(SK_MaxS64FitsInFloat)
+    x = x < SK_MaxS64FitsInFloat ? x : SK_MaxS64FitsInFloat;
+    x = x > SK_MinS64FitsInFloat ? x : SK_MinS64FitsInFloat;
+    return (int64_t)x;
+}
+
+#undef SK_CHECK_NAN
+
+#define sk_float_floor2int(x)   sk_float_saturate2int(std::floor(x))
+#define sk_float_round2int(x)   sk_float_saturate2int(sk_float_round(x))
+#define sk_float_ceil2int(x)    sk_float_saturate2int(std::ceil(x))
+
+#define sk_float_floor2int_no_saturate(x)   ((int)std::floor(x))
+#define sk_float_round2int_no_saturate(x)   ((int)sk_float_round(x))
+#define sk_float_ceil2int_no_saturate(x)    ((int)std::ceil(x))
+
+#define sk_double_round(x)          (std::floor((x) + 0.5))
+#define sk_double_floor2int(x)      ((int)std::floor(x))
+#define sk_double_round2int(x)      ((int)std::round(x))
+#define sk_double_ceil2int(x)       ((int)std::ceil(x))
+
+// Cast double to float, ignoring any warning about too-large finite values being cast to float.
+// Clang thinks this is undefined, but it's actually implementation defined to return either
+// the largest float or infinity (one of the two bracketing representable floats).  Good enough!
+SK_NO_SANITIZE("float-cast-overflow")
+static constexpr float sk_double_to_float(double x) {
+    return static_cast<float>(x);
+}
+
+inline constexpr float SK_FloatNaN = std::numeric_limits<float>::quiet_NaN();
+inline constexpr float SK_FloatInfinity = std::numeric_limits<float>::infinity();
+inline constexpr float SK_FloatNegativeInfinity = -SK_FloatInfinity;
+
+inline constexpr double SK_DoubleNaN = std::numeric_limits<double>::quiet_NaN();
+
+// Calculate the midpoint between a and b. Similar to std::midpoint in c++20.
+static constexpr float sk_float_midpoint(float a, float b) {
+    // Use double math to avoid underflow and overflow.
+    return static_cast<float>(0.5 * (static_cast<double>(a) + b));
+}
+
+static inline float sk_float_rsqrt (float x) { return 1.0f / std::sqrt(x); }
+
+// IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not,
+// so we have a helper that suppresses the possible undefined-behavior warnings.
+#ifdef SK_BUILD_FOR_WIN
+#pragma warning(push)
+#pragma warning(disable : 4723)
+#endif
+SK_NO_SANITIZE("float-divide-by-zero")
+static constexpr float sk_ieee_float_divide(float numer, float denom) {
+    return numer / denom;
+}
+
+SK_NO_SANITIZE("float-divide-by-zero")
+static constexpr double sk_ieee_double_divide(double numer, double denom) {
+    return numer / denom;
+}
+#ifdef SK_BUILD_FOR_WIN
+#pragma warning( pop )
+#endif
+
+// Returns true iff the provided number is within a small epsilon of 0.
+bool sk_double_nearly_zero(double a);
+
+// Compare two doubles and return true if they are within maxUlpsDiff of each other.
+// * nan as a or b - returns false.
+// * infinity, infinity or -infinity, -infinity - returns true.
+// * infinity and any other number - returns false.
+//
+// ulp is an initialism for Units in the Last Place.
+bool sk_doubles_nearly_equal_ulps(double a, double b, uint8_t maxUlpsDiff = 16);
+
+#endif

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

@@ -0,0 +1,140 @@
+/*
+ * 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 SkGainmapInfo_DEFINED
+#define SkGainmapInfo_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkRefCnt.h"
+class SkData;
+
+/**
+ *  Gainmap rendering parameters. Suppose our display has HDR to SDR ratio of H and we wish to
+ *  display an image with gainmap on this display. Let B be the pixel value from the base image
+ *  in a color space that has the primaries of the base image and a linear transfer function. Let
+ *  G be the pixel value from the gainmap. Let D be the output pixel in the same color space as B.
+ *  The value of D is computed as follows:
+ *
+ *  First, let W be a weight parameter determing how much the gainmap will be applied.
+ *    W = clamp((log(H)                - log(fDisplayRatioSdr)) /
+ *              (log(fDisplayRatioHdr) - log(fDisplayRatioSdr), 0, 1)
+ *
+ *  Next, let L be the gainmap value in log space. We compute this from the value G that was
+ *  sampled from the texture as follows:
+ *    L = mix(log(fGainmapRatioMin), log(fGainmapRatioMax), pow(G, fGainmapGamma))
+ *
+ *  Finally, apply the gainmap to compute D, the displayed pixel. If the base image is SDR then
+ *  compute:
+ *    D = (B + fEpsilonSdr) * exp(L * W) - fEpsilonHdr
+ *  If the base image is HDR then compute:
+ *    D = (B + fEpsilonHdr) * exp(L * (W - 1)) - fEpsilonSdr
+ *
+ *  In the above math, log() is a natural logarithm and exp() is natural exponentiation. Note,
+ *  however, that the base used for the log() and exp() functions does not affect the results of
+ *  the computation (it cancels out, as long as the same base is used throughout).
+ *
+ *  This product includes Gain Map technology under license by Adobe.
+ */
+struct SkGainmapInfo {
+    /**
+     *  Parameters for converting the gainmap from its image encoding to log space. These are
+     *  specified per color channel. The alpha value is unused.
+     */
+    SkColor4f fGainmapRatioMin = {1.f, 1.f, 1.f, 1.0};
+    SkColor4f fGainmapRatioMax = {2.f, 2.f, 2.f, 1.0};
+    SkColor4f fGainmapGamma = {1.f, 1.f, 1.f, 1.f};
+
+    /**
+     *  Parameters sometimes used in gainmap computation to avoid numerical instability.
+     */
+    SkColor4f fEpsilonSdr = {0.f, 0.f, 0.f, 1.0};
+    SkColor4f fEpsilonHdr = {0.f, 0.f, 0.f, 1.0};
+
+    /**
+     *  If the output display's HDR to SDR ratio is less or equal than fDisplayRatioSdr then the SDR
+     *  rendition is displayed. If the output display's HDR to SDR ratio is greater or equal than
+     *  fDisplayRatioHdr then the HDR rendition is displayed. If the output display's HDR to SDR
+     *  ratio is between these values then an interpolation between the two is displayed using the
+     *  math above.
+     */
+    float fDisplayRatioSdr = 1.f;
+    float fDisplayRatioHdr = 2.f;
+
+    /**
+     *  Whether the base image is the SDR image or the HDR image.
+     */
+    enum class BaseImageType {
+        kSDR,
+        kHDR,
+    };
+    BaseImageType fBaseImageType = BaseImageType::kSDR;
+
+    /**
+     *  The type of the gainmap image. If the type is kApple, then the gainmap image was originally
+     *  encoded according to the specification at [0], and can be converted to the kDefault type by
+     *  applying the transformation described at [1].
+     *  [0] https://developer.apple.com/documentation/appkit/images_and_pdf/
+     *      applying_apple_hdr_effect_to_your_photos
+     *  [1] https://docs.google.com/document/d/1iUpYAThVV_FuDdeiO3t0vnlfoA1ryq0WfGS9FuydwKc
+     */
+    enum class Type {
+        kDefault,
+        kApple,
+    };
+    Type fType = Type::kDefault;
+
+    /**
+     * If specified, color space to apply the gainmap in, otherwise the base image's color space
+     * is used. Only the color primaries are used, the transfer function is irrelevant.
+     */
+    sk_sp<SkColorSpace> fGainmapMathColorSpace = nullptr;
+
+    /**
+     * Return true if this can be encoded as an UltraHDR v1 image.
+     */
+    bool isUltraHDRv1Compatible() const;
+
+    /**
+     * If |data| contains an ISO 21496-1 version that is supported, return true. Otherwise return
+     * false.
+     */
+    static bool ParseVersion(const SkData* data);
+
+    /**
+     * If |data| constains ISO 21496-1 metadata then parse that metadata then use it to populate
+     * |info| and return true, otherwise return false. If |data| indicates that that the base image
+     * color space primaries should be used for gainmap application then set
+     * |fGainmapMathColorSpace| to nullptr, otherwise set |fGainmapMathColorSpace| to sRGB (the
+     * default, to be overwritten by the image decoder).
+     */
+    static bool Parse(const SkData* data, SkGainmapInfo& info);
+
+    /**
+     * Serialize an ISO 21496-1 version 0 blob containing only the version structure.
+     */
+    static sk_sp<SkData> SerializeVersion();
+
+    /**
+     * Serialize an ISO 21496-1 version 0 blob containing this' gainmap parameters.
+     */
+    sk_sp<SkData> serialize() const;
+
+    inline bool operator==(const SkGainmapInfo& other) const {
+        return fGainmapRatioMin == other.fGainmapRatioMin &&
+               fGainmapRatioMax == other.fGainmapRatioMax && fGainmapGamma == other.fGainmapGamma &&
+               fEpsilonSdr == other.fEpsilonSdr && fEpsilonHdr == other.fEpsilonHdr &&
+               fDisplayRatioSdr == other.fDisplayRatioSdr &&
+               fDisplayRatioHdr == other.fDisplayRatioHdr &&
+               fBaseImageType == other.fBaseImageType && fType == other.fType &&
+               SkColorSpace::Equals(fGainmapMathColorSpace.get(),
+                                    other.fGainmapMathColorSpace.get());
+    }
+    inline bool operator!=(const SkGainmapInfo& other) const { return !(*this == other); }
+};
+
+#endif