@shopify/react-native-skia 1.12.0 → 1.12.2

package/cpp/skia/include/gpu/graphite/Image.h

@@ -15,6 +15,7 @@
 #include "include/gpu/GpuTypes.h"
 
 #include <string_view>
+#include <tuple>
 
 class SkYUVAInfo;
 class SkYUVAPixmaps;

package/cpp/skia/include/gpu/graphite/LogPriority.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_LogPriority_DEFINED
+#define skgpu_graphite_LogPriority_DEFINED
+
+/**
+ * Note: this file may be included in clients' SkUserConfig.h files, so including any other headers
+ * in this file should be avoided.
+ */
+
+namespace skgpu::graphite {
+/**
+ * SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY can be defined to one of these values (in
+ * SkUserConfig.h) to control Graphite's logging behavior.
+ *
+ * For example:
+ * ```
+ * #define SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY skgpu::graphite::LogPriority::kWarning
+ * ```
+ * Would cause Graphite to log warnings, non-fatal errors, and fatal errors.
+ * However, debug logs would be omitted.
+ */
+enum class LogPriority : int {
+    kFatal = 0,
+    kError = 1,
+    kWarning = 2,
+    kDebug = 3,
+};
+};  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_LogPriority_DEFINED

package/cpp/skia/include/gpu/graphite/PrecompileContext.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_PrecompileContext_DEFINED
+#define skgpu_graphite_PrecompileContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SingleOwner.h"
+
+#include <chrono>
+#include <memory>
+
+namespace skgpu::graphite {
+
+class SharedContext;
+class PrecompileContextPriv;
+class ResourceProvider;
+
+class SK_API PrecompileContext {
+public:
+    ~PrecompileContext();
+
+    /**
+     * Purge Pipelines that haven't been used in the past 'msNotUsed' milliseconds
+     * regardless of whether the pipeline cache is under budget.
+     *
+     * @param msNotUsed   Pipelines not used in these last milliseconds will be cleaned up.
+     */
+    void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileContextPriv priv();
+    const PrecompileContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    friend class PrecompileContextPriv;
+    friend class Context; // for ctor
+
+    PrecompileContext(sk_sp<SharedContext>);
+
+    mutable SingleOwner fSingleOwner;
+    sk_sp<SharedContext> fSharedContext;
+    std::unique_ptr<ResourceProvider> fResourceProvider;
+};
+
+}  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_PrecompileContext_DEFINED

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -209,6 +209,12 @@ public:
      */
     size_t maxBudgetedBytes() const;
 
+    /**
+     * Sets the size of Recorders's gpu memory cache budget in bytes. If the new budget is lower
+     * than the current budget, the cache will try to free resources to get under the new budget.
+     */
+    void setMaxBudgetedBytes(size_t bytes);
+
     /**
      * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
      * traceMemoryDump.

package/cpp/skia/include/gpu/graphite/Recording.h

@@ -9,6 +9,7 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
 #include "include/private/base/SkTArray.h"
 
 #include <memory>
@@ -21,6 +22,7 @@ class RefCntedCallback;
 
 namespace skgpu::graphite {
 
+class Caps;
 class CommandBuffer;
 class RecordingPriv;
 class Resource;
@@ -44,7 +46,7 @@ private:
     // replay, and it handles the target proxy's instantiation with the provided target.
     class LazyProxyData {
     public:
-        LazyProxyData(const TextureInfo&);
+        LazyProxyData(const Caps*, SkISize dimensions, const TextureInfo&);
 
         TextureProxy* lazyProxy();
         sk_sp<TextureProxy> refLazyProxy();

package/cpp/skia/include/gpu/graphite/mtl/MtlGraphiteTypes.h

@@ -8,27 +8,19 @@
 #ifndef skgpu_graphite_MtlGraphiteTypes_DEFINED
 #define skgpu_graphite_MtlGraphiteTypes_DEFINED
 
+#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
+
 #include "include/core/SkTypes.h"
 
-#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
-#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/TextureInfo.h"
-#include "include/ports/SkCFObject.h"
+#include "include/gpu/graphite/mtl/MtlGraphiteTypesUtils.h"
 #include "include/private/base/SkAPI.h"
 
 #import <CoreFoundation/CoreFoundation.h>
 #import <Metal/Metal.h>
 #import <TargetConditionals.h>
 
-#if TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
-#else  // TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
-#endif  // TARGET_OS_SIMULATOR
-
 namespace skgpu::graphite {
-
 struct SK_API MtlTextureInfo {
     uint32_t fSampleCount = 1;
     skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
@@ -53,31 +45,7 @@ struct SK_API MtlTextureInfo {
             , fStorageMode(storageMode)
             , fFramebufferOnly(framebufferOnly) {}
 };
-
-namespace TextureInfos {
-SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
-SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
-
-SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
-}  // namespace TextureInfos
-
-namespace BackendTextures {
-// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
-// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
-SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
-
-SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
-}  // namespace BackendTextures
-
-namespace BackendSemaphores {
-// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
-SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
-
-SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
-SK_API uint64_t GetMtlValue(const BackendSemaphore&);
-}  // namespace BackendSemaphores
-
-} // namespace skgpu::graphite
+}  // namespace skgpu::graphite
 
 #endif  // __OBJC__
 

package/cpp/skia/include/gpu/graphite/mtl/MtlGraphiteTypesUtils.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+#define skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkAPI.h"
+
+#import <CoreFoundation/CoreFoundation.h>
+
+namespace skgpu::graphite {
+
+struct SK_API MtlTextureInfo;
+
+namespace TextureInfos {
+SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
+SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
+
+SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
+
+SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
+SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
+
+SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
+SK_API uint64_t GetMtlValue(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_MtlGraphiteTypesUtils_DEFINED

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

@@ -15,6 +15,7 @@ namespace skgpu::graphite {
 
 class Context;
 class PaintOptions;
+class PrecompileContext;
 
 /**
  *  Describes the required properties of a RenderPass that will be combined with the
@@ -33,12 +34,12 @@ struct SK_API RenderPassProperties {
  * drawing. Graphite will always be able to perform an inline compilation if some SkPaint
  * combination was omitted from precompilation.
  *
- *   @param context              the Context to which the actual draws will be submitted
+ *   @param precompileContext    thread-safe helper holding required portions of the Context
  *   @param paintOptions         captures a set of SkPaints that will be drawn
  *   @param drawTypes            communicates which primitives those paints will be drawn with
  *   @param renderPassProperties describes the RenderPasses needed for the desired Pipelines
  */
-void SK_API Precompile(Context* context,
+void SK_API Precompile(PrecompileContext* precompileContext,
                        const PaintOptions& paintOptions,
                        DrawTypeFlags drawTypes,
                        SkSpan<const RenderPassProperties> renderPassProperties);

package/cpp/skia/include/pathops/SkPathOps.h

@@ -65,7 +65,15 @@ bool SK_API Simplify(const SkPath& path, SkPath* result);
     @param result The tight bounds of the path.
     @return True if the bounds could be computed.
   */
-bool SK_API TightBounds(const SkPath& path, SkRect* result);
+[[deprecated]]
+static inline bool TightBounds(const SkPath& path, SkRect* result) {
+    auto rect = path.computeTightBounds();
+    if (rect.isFinite()) {
+        *result = rect;
+        return true;
+    }
+    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

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

@@ -13,8 +13,11 @@
 
 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);
 
 #endif // #ifndef SkFontMgr_FontConfigInterface_DEFINED

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

@@ -28,15 +28,6 @@
 class SkMatrix;
 class SkRRect;
 
-// These are computed from a stream of verbs
-struct SkPathVerbAnalysis {
-    bool     valid;
-    int      points, weights;
-    unsigned segmentMask;
-};
-SkPathVerbAnalysis sk_path_analyze_verbs(const uint8_t verbs[], int count);
-
-
 /**
  * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
  * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
@@ -541,7 +532,12 @@ private:
 
     void callGenIDChangeListeners();
 
+    PointsArray fPoints;
+    VerbsArray fVerbs;
+    ConicWeightsArray fConicWeights;
+
     mutable SkRect   fBounds;
+    SkRect           fArcOval;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
@@ -549,27 +545,25 @@ private:
     mutable uint32_t    fGenerationID;
     SkIDChangeListener::List fGenIDChangeListeners;
 
-    PointsArray fPoints;
-    VerbsArray fVerbs;
-    ConicWeightsArray fConicWeights;
-
     SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
 
-    mutable uint8_t  fBoundsIsDirty;
-    mutable bool     fIsFinite;    // only meaningful if bounds are valid
+    SkScalar    fArcStartAngle;
+    SkScalar    fArcSweepAngle;
 
     PathType fType;
-    // Both the circle and rrect special cases have a notion of direction and starting point
-    // The next two variables store that information for either.
-    bool     fRRectOrOvalIsCCW;
+
+    mutable uint8_t  fBoundsIsDirty;
+
     uint8_t  fRRectOrOvalStartIdx;
     uint8_t  fSegmentMask;
     // If the path is an arc, these four variables store that information.
     // We should just store an SkArc, but alignment would cost us 8 more bytes.
     SkArc::Type fArcType;
-    SkRect      fArcOval;
-    SkScalar    fArcStartAngle;
-    SkScalar    fArcSweepAngle;
+
+    mutable bool     fIsFinite;    // only meaningful if bounds are valid
+    // Both the circle and rrect special cases have a notion of direction and starting point
+    // The next two variables store that information for either.
+    bool     fRRectOrOvalIsCCW;
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect

package/cpp/skia/include/private/base/SkAttributes.h

@@ -56,20 +56,26 @@
  * Used to ignore sanitizer warnings.
  */
 #if !defined(SK_NO_SANITIZE)
-#  define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+  #if defined(__has_attribute)
+    #if __has_attribute(no_sanitize)
+      // This should be for clang and versions of gcc >= 8.0
+      #define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+    #else
+      // For compilers that don't support sanitization, just do nothing.
+      #define SK_NO_SANITIZE(A)
+    #endif
+  #else // no __has_attribute, e.g. MSVC
+    #define SK_NO_SANITIZE(A)
+  #endif
 #endif
 
 /**
- * Helper macro to define no_sanitize attributes only with clang.
+ * Used to ignore CFI sanitizer warnings, supported only by Clang at the moment.
  */
-#if defined(__clang__) && defined(__has_attribute)
-  #if __has_attribute(no_sanitize)
-    #define SK_CLANG_NO_SANITIZE(A) SK_NO_SANITIZE(A)
-  #endif
-#endif
-
-#if !defined(SK_CLANG_NO_SANITIZE)
-  #define SK_CLANG_NO_SANITIZE(A)
+#if defined(__clang__)
+  #define SK_NO_SANITIZE_CFI SK_NO_SANITIZE("cfi")
+#else
+  #define SK_NO_SANITIZE_CFI
 #endif
 
 /**

package/cpp/skia/include/private/base/SkMutex.h

@@ -14,6 +14,14 @@
 #include "include/private/base/SkThreadAnnotations.h"
 #include "include/private/base/SkThreadID.h"
 
+/**
+ * class SkMutex
+ *
+ * This allows us to have a mutex without needing the one in
+ * the C++ std library which does not work with all clients.
+ * go/cstyle#Disallowed_Stdlib
+ */
+
 class SK_CAPABILITY("mutex") SkMutex {
 public:
     constexpr SkMutex() = default;

package/cpp/skia/include/private/base/SkTArray.h

@@ -617,7 +617,7 @@ private:
     // unpredictable location in memory. Of course, TArray won't actually use fItemArray in this
     // way, and we don't want to construct a T before the user requests one. There's no real risk
     // here, so disable CFI when doing these casts.
-    SK_CLANG_NO_SANITIZE("cfi")
+    SK_NO_SANITIZE_CFI
     static T* TCast(void* buffer) {
         return (T*)buffer;
     }

package/cpp/skia/include/private/base/SkTDArray.h

@@ -13,9 +13,9 @@
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
 
-#include <algorithm>
 #include <cstddef>
 #include <initializer_list>
+#include <utility>
 
 class SK_SPI SkTDStorage {
 public:

package/cpp/skia/include/private/base/SkTemplates.h

@@ -15,6 +15,7 @@
 #include "include/private/base/SkTLogic.h"
 #include "include/private/base/SkTo.h"
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -94,7 +95,8 @@ public:
 
 
 namespace skia_private {
-/** Allocate an array of T elements, and free the array in the destructor
+/** Allocate an array of T elements on the heap. Once this goes out of scope, the
+ *  elements will be cleaned up "auto"matically.
  */
 template <typename T> class AutoTArray  {
 public:
@@ -164,7 +166,10 @@ private:
     size_t fSize = 0;
 };
 
-/** Wraps AutoTArray, with room for kCountRequested elements preallocated.
+/** Like AutoTArray with room for kCountRequested elements preallocated on
+ *  the Stack. If count exceeds the space of the preallocation, the elements
+ *  will live on the heap. Once this goes out of scope, the elements will be
+ *  cleaned up "auto"matically.
  */
 template <int kCountRequested, typename T> class AutoSTArray {
 public:
@@ -256,17 +261,25 @@ private:
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max,
     // but some functions have multiple large stack allocations.
-    static const int kMaxBytes = 4 * 1024;
-    static const int kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static constexpr int kMaxBytes = 4 * 1024;
+    static constexpr int kMinCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountRequested;
 #else
-    static const int kCount = kCountRequested;
+    static constexpr int kMinCount = kCountRequested;
 #endif
 
-    int fCount;
+    // Because we are also storing an int, there is a tiny bit of padding that
+    // the C++ compiler adds after fStorage if sizeof(T) <= alignof(T*).
+    // Thus, we can expand how many elements are stored on the stack to make use of this
+    // (e.g. 1 extra element for 4 byte T if kCountRequested was even).
+    static_assert(alignof(int) <= alignof(T*) || alignof(int) <= alignof(T));
+    static constexpr int kCount =
+            SkAlignTo(kMinCount*sizeof(T) + sizeof(int), std::max(alignof(T*), alignof(T))) / sizeof(T);
+
     T* fArray;
-    alignas(T) char fStorage[kCount * sizeof(T)];
+    alignas(T) std::byte fStorage[kCount * sizeof(T)];
+    int fCount;
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
@@ -409,16 +422,16 @@ public:
 
 private:
     // Since we use uint32_t storage, we might be able to get more elements for free.
-    static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
+    static constexpr size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
     // have multiple large stack allocations.
-    static const size_t kMaxBytes = 4 * 1024;
-    static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static constexpr size_t kMaxBytes = 4 * 1024;
+    static constexpr size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountWithPadding;
 #else
-    static const size_t kCount = kCountWithPadding;
+    static constexpr size_t kCount = kCountWithPadding;
 #endif
 
     T*          fPtr;

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -539,7 +539,7 @@ SK_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
 enum class GrColorType {
     kUnknown,
     kAlpha_8,
-    kBGR_565,
+    kBGR_565,    // This corresponds to kRGB_565_SkColorType, which is misnamed.
     kRGB_565,
     kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
     kRGBA_8888,

package/cpp/skia/include/sksl/SkSLDebugTrace.h

@@ -16,9 +16,6 @@ namespace SkSL {
 
 class DebugTrace : public SkRefCnt {
 public:
-    /** Serializes a debug trace to JSON which can be parsed by our debugger. */
-    virtual void writeTrace(SkWStream* w) const = 0;
-
     /** Generates a human-readable dump of the debug trace. */
     virtual void dump(SkWStream* o) const = 0;
 };

package/cpp/skia/modules/skcms/src/Transform_inl.h

@@ -904,24 +904,19 @@ STAGE(load_1010102, NoCtx) {
 }
 
 STAGE(load_101010x_XR, NoCtx) {
-    static constexpr float min = -0.752941f;
-    static constexpr float max = 1.25098f;
-    static constexpr float range = max - min;
     U32 rgba = load<U32>(src + 4*i);
-    r = cast<F>((rgba >>  0) & 0x3ff) * (1/1023.0f) * range + min;
-    g = cast<F>((rgba >> 10) & 0x3ff) * (1/1023.0f) * range + min;
-    b = cast<F>((rgba >> 20) & 0x3ff) * (1/1023.0f) * range + min;
+    r = cast<F>(((rgba >>  0) & 0x3ff) - 384) / 510.0f;
+    g = cast<F>(((rgba >> 10) & 0x3ff) - 384) / 510.0f;
+    b = cast<F>(((rgba >> 20) & 0x3ff) - 384) / 510.0f;
 }
 
 STAGE(load_10101010_XR, NoCtx) {
-    static constexpr float min = -0.752941f;
-    static constexpr float max = 1.25098f;
-    static constexpr float range = max - min;
     U64 rgba = load<U64>(src + 8 * i);
-    r = cast<F>((rgba >>  (0+6)) & 0x3ff) * (1/1023.0f) * range + min;
-    g = cast<F>((rgba >> (16+6)) & 0x3ff) * (1/1023.0f) * range + min;
-    b = cast<F>((rgba >> (32+6)) & 0x3ff) * (1/1023.0f) * range + min;
-    a = cast<F>((rgba >> (48+6)) & 0x3ff) * (1/1023.0f) * range + min;
+    // Each channel is 16 bits, where the 6 low bits are padding.
+    r = cast<F>(((rgba >> ( 0+6)) & 0x3ff) - 384) / 510.0f;
+    g = cast<F>(((rgba >> (16+6)) & 0x3ff) - 384) / 510.0f;
+    b = cast<F>(((rgba >> (32+6)) & 0x3ff) - 384) / 510.0f;
+    a = cast<F>(((rgba >> (48+6)) & 0x3ff) - 384) / 510.0f;
 }
 
 STAGE(load_161616LE, NoCtx) {
@@ -1310,12 +1305,17 @@ FINAL_STAGE(store_8888, NoCtx) {
 }
 
 FINAL_STAGE(store_101010x_XR, NoCtx) {
-    static constexpr float min = -0.752941f;
-    static constexpr float max = 1.25098f;
-    static constexpr float range = max - min;
-    store(dst + 4*i, cast<U32>(to_fixed(((r - min) / range) * 1023)) <<  0
-                   | cast<U32>(to_fixed(((g - min) / range) * 1023)) << 10
-                   | cast<U32>(to_fixed(((b - min) / range) * 1023)) << 20);
+    store(dst + 4*i, cast<U32>(to_fixed((r * 510) + 384)) <<  0
+                   | cast<U32>(to_fixed((g * 510) + 384)) << 10
+                   | cast<U32>(to_fixed((b * 510) + 384)) << 20);
+}
+
+FINAL_STAGE(store_10101010_XR, NoCtx) {
+    // Each channel is 16 bits, where the 6 low bits are padding.
+    store(dst + 8*i, cast<U64>(to_fixed((r * 510) + 384)) << ( 0+6)
+                   | cast<U64>(to_fixed((g * 510) + 384)) << (16+6)
+                   | cast<U64>(to_fixed((b * 510) + 384)) << (32+6)
+                   | cast<U64>(to_fixed((a * 510) + 384)) << (48+6));
 }
 
 FINAL_STAGE(store_1010102, NoCtx) {
@@ -1521,7 +1521,7 @@ FINAL_STAGE(store_ffff, NoCtx) {
 // NOLINTNEXTLINE(misc-definitions-in-headers)
 void run_program(const Op* program, const void** contexts, SKCMS_MAYBE_UNUSED ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                 const size_t src_bpp, const size_t dst_bpp) {
+                size_t src_bpp, size_t dst_bpp) {
 #if SKCMS_HAS_MUSTTAIL
     // Convert the program into an array of tailcall stages.
     StageFn stages[32];

package/cpp/skia/modules/skcms/src/skcms_Transform.h

@@ -101,6 +101,7 @@ namespace skcms_private {
     M(store_161616BE)      \
     M(store_16161616BE)    \
     M(store_101010x_XR)    \
+    M(store_10101010_XR)   \
     M(store_hhh)           \
     M(store_hhhh)          \
     M(store_fff)           \
@@ -144,21 +145,21 @@ namespace baseline {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                 const size_t src_bpp, const size_t dst_bpp);
+                size_t src_bpp, size_t dst_bpp);
 
 }
 namespace hsw {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                 const size_t src_bpp, const size_t dst_bpp);
+                size_t src_bpp, size_t dst_bpp);
 
 }
 namespace skx {
 
 void run_program(const Op* program, const void** contexts, ptrdiff_t programSize,
                  const char* src, char* dst, int n,
-                 const size_t src_bpp, const size_t dst_bpp);
+                size_t src_bpp, size_t dst_bpp);
 
 }
 }  // namespace skcms_private