@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -14,9 +14,8 @@
 #include "include/core/SkPath.h"
 #include "include/core/SkPathTypes.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkTextureCompressionType.h"
-#include "include/gpu/GrTypes.h"
 #include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
 #include "include/private/base/SkMacros.h"
 #include "include/private/base/SkTypeTraits.h"
 
@@ -254,7 +253,7 @@ enum class GrQuadAAFlags {
     kAll  = 0b1111,
 };
 
-GR_MAKE_BITFIELD_CLASS_OPS(GrQuadAAFlags)
+SK_MAKE_BITFIELD_CLASS_OPS(GrQuadAAFlags)
 
 static inline GrQuadAAFlags SkToGrQuadAAFlags(unsigned flags) {
     return static_cast<GrQuadAAFlags>(flags);
@@ -462,9 +461,9 @@ enum class GrInternalSurfaceFlags {
     kVkRTSupportsInputAttachment    = 1 << 4,
 };
 
-GR_MAKE_BITFIELD_CLASS_OPS(GrInternalSurfaceFlags)
+SK_MAKE_BITFIELD_CLASS_OPS(GrInternalSurfaceFlags)
 
-// 'GR_MAKE_BITFIELD_CLASS_OPS' defines the & operator on GrInternalSurfaceFlags to return bool.
+// 'SK_MAKE_BITFIELD_CLASS_OPS' defines the & operator on GrInternalSurfaceFlags to return bool.
 // We want to find the bitwise & with these masks, so we declare them as ints.
 constexpr static int kGrInternalTextureFlagsMask = static_cast<int>(
         GrInternalSurfaceFlags::kReadOnly);
@@ -526,7 +525,7 @@ enum class GrMipmapStatus {
     kValid,        // All levels fully allocated and have valid data in them
 };
 
-GR_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
+SK_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
 
 /**
  * Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels,
@@ -550,11 +549,13 @@ enum class GrColorType {
     kBGRA_8888,
     kRGBA_1010102,
     kBGRA_1010102,
+    kRGB_101010x,
     kRGBA_10x6,
     kGray_8,
     kGrayAlpha_88,
     kAlpha_F16,
     kRGBA_F16,
+    kRGB_F16F16F16x,
     kRGBA_F16_Clamped,
     kRGBA_F32,
 
@@ -600,12 +601,14 @@ static constexpr SkColorType GrColorTypeToSkColorType(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return kBGRA_8888_SkColorType;
         case GrColorType::kRGBA_1010102:     return kRGBA_1010102_SkColorType;
         case GrColorType::kBGRA_1010102:     return kBGRA_1010102_SkColorType;
+        case GrColorType::kRGB_101010x:      return kRGB_101010x_SkColorType;
         case GrColorType::kRGBA_10x6:        return kRGBA_10x6_SkColorType;
         case GrColorType::kGray_8:           return kGray_8_SkColorType;
         case GrColorType::kGrayAlpha_88:     return kUnknown_SkColorType;
         case GrColorType::kAlpha_F16:        return kA16_float_SkColorType;
         case GrColorType::kRGBA_F16:         return kRGBA_F16_SkColorType;
         case GrColorType::kRGBA_F16_Clamped: return kRGBA_F16Norm_SkColorType;
+        case GrColorType::kRGB_F16F16F16x:   return kRGB_F16F16F16x_SkColorType;
         case GrColorType::kRGBA_F32:         return kRGBA_F32_SkColorType;
         case GrColorType::kAlpha_8xxx:       return kUnknown_SkColorType;
         case GrColorType::kAlpha_F32xxx:     return kUnknown_SkColorType;
@@ -639,11 +642,13 @@ static constexpr GrColorType SkColorTypeToGrColorType(SkColorType ct) {
         case kGray_8_SkColorType:             return GrColorType::kGray_8;
         case kRGBA_F16Norm_SkColorType:       return GrColorType::kRGBA_F16_Clamped;
         case kRGBA_F16_SkColorType:           return GrColorType::kRGBA_F16;
+        case kRGB_F16F16F16x_SkColorType:     return GrColorType::kRGB_F16F16F16x;
         case kRGBA_1010102_SkColorType:       return GrColorType::kRGBA_1010102;
-        case kRGB_101010x_SkColorType:        return GrColorType::kUnknown;
+        case kRGB_101010x_SkColorType:        return GrColorType::kRGB_101010x;
         case kBGRA_1010102_SkColorType:       return GrColorType::kBGRA_1010102;
         case kBGR_101010x_SkColorType:        return GrColorType::kUnknown;
         case kBGR_101010x_XR_SkColorType:     return GrColorType::kUnknown;
+        case kBGRA_10101010_XR_SkColorType:   return GrColorType::kUnknown;
         case kRGBA_10x6_SkColorType:          return GrColorType::kRGBA_10x6;
         case kRGBA_F32_SkColorType:           return GrColorType::kRGBA_F32;
         case kR8G8_unorm_SkColorType:         return GrColorType::kRG_88;
@@ -671,12 +676,14 @@ static constexpr uint32_t GrColorTypeChannelFlags(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kRGBA_1010102:     return kRGBA_SkColorChannelFlags;
         case GrColorType::kBGRA_1010102:     return kRGBA_SkColorChannelFlags;
+        case GrColorType::kRGB_101010x:      return kRGB_SkColorChannelFlags;
         case GrColorType::kRGBA_10x6:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kGray_8:           return kGray_SkColorChannelFlag;
         case GrColorType::kGrayAlpha_88:     return kGrayAlpha_SkColorChannelFlags;
         case GrColorType::kAlpha_F16:        return kAlpha_SkColorChannelFlag;
         case GrColorType::kRGBA_F16:         return kRGBA_SkColorChannelFlags;
         case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorChannelFlags;
+        case GrColorType::kRGB_F16F16F16x:   return kRGB_SkColorChannelFlags;
         case GrColorType::kRGBA_F32:         return kRGBA_SkColorChannelFlags;
         case GrColorType::kAlpha_8xxx:       return kAlpha_SkColorChannelFlag;
         case GrColorType::kAlpha_F32xxx:     return kAlpha_SkColorChannelFlag;
@@ -816,6 +823,8 @@ static constexpr GrColorFormatDesc GrGetColorTypeDesc(GrColorType ct) {
             return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
         case GrColorType::kBGRA_1010102:
             return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
+        case GrColorType::kRGB_101010x:
+            return GrColorFormatDesc::MakeRGB(10, GrColorTypeEncoding::kUnorm);
         case GrColorType::kRGBA_10x6:
             return GrColorFormatDesc::MakeRGBA(10, GrColorTypeEncoding::kUnorm);
         case GrColorType::kGray_8:
@@ -826,6 +835,8 @@ static constexpr GrColorFormatDesc GrGetColorTypeDesc(GrColorType ct) {
             return GrColorFormatDesc::MakeAlpha(16, GrColorTypeEncoding::kFloat);
         case GrColorType::kRGBA_F16:
             return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
+        case GrColorType::kRGB_F16F16F16x:
+            return GrColorFormatDesc::MakeRGB(16, GrColorTypeEncoding::kFloat);
         case GrColorType::kRGBA_F16_Clamped:
             return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
         case GrColorType::kRGBA_F32:
@@ -906,12 +917,14 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return 4;
         case GrColorType::kRGBA_1010102:     return 4;
         case GrColorType::kBGRA_1010102:     return 4;
+        case GrColorType::kRGB_101010x:      return 4;
         case GrColorType::kRGBA_10x6:        return 8;
         case GrColorType::kGray_8:           return 1;
         case GrColorType::kGrayAlpha_88:     return 2;
         case GrColorType::kAlpha_F16:        return 2;
         case GrColorType::kRGBA_F16:         return 8;
         case GrColorType::kRGBA_F16_Clamped: return 8;
+        case GrColorType::kRGB_F16F16F16x:   return 8;
         case GrColorType::kRGBA_F32:         return 16;
         case GrColorType::kAlpha_8xxx:       return 4;
         case GrColorType::kAlpha_F32xxx:     return 16;
@@ -932,98 +945,13 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
     SkUNREACHABLE;
 }
 
-// In general we try to not mix CompressionType and ColorType, but currently SkImage still requires
-// an SkColorType even for CompressedTypes so we need some conversion.
-static constexpr SkColorType GrCompressionTypeToSkColorType(SkTextureCompressionType compression) {
-    switch (compression) {
-        case SkTextureCompressionType::kNone:            return kUnknown_SkColorType;
-        case SkTextureCompressionType::kETC2_RGB8_UNORM: return kRGB_888x_SkColorType;
-        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return kRGB_888x_SkColorType;
-        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return kRGBA_8888_SkColorType;
-    }
-
-    SkUNREACHABLE;
-}
-
 enum class GrDstSampleFlags {
     kNone = 0,
     kRequiresTextureBarrier =   1 << 0,
     kAsInputAttachment = 1 << 1,
 };
-GR_MAKE_BITFIELD_CLASS_OPS(GrDstSampleFlags)
+SK_MAKE_BITFIELD_CLASS_OPS(GrDstSampleFlags)
 
 using GrVisitProxyFunc = std::function<void(GrSurfaceProxy*, skgpu::Mipmapped)>;
 
-#if defined(SK_DEBUG) || defined(GR_TEST_UTILS) || defined(SK_ENABLE_DUMP_GPU)
-static constexpr const char* GrBackendApiToStr(GrBackendApi api) {
-    switch (api) {
-        case GrBackendApi::kOpenGL:      return "OpenGL";
-        case GrBackendApi::kVulkan:      return "Vulkan";
-        case GrBackendApi::kMetal:       return "Metal";
-        case GrBackendApi::kDirect3D:    return "Direct3D";
-        case GrBackendApi::kMock:        return "Mock";
-        case GrBackendApi::kUnsupported: return "Unsupported";
-    }
-    SkUNREACHABLE;
-}
-
-static constexpr const char* GrColorTypeToStr(GrColorType ct) {
-    switch (ct) {
-        case GrColorType::kUnknown:          return "kUnknown";
-        case GrColorType::kAlpha_8:          return "kAlpha_8";
-        case GrColorType::kBGR_565:          return "kBGR_565";
-        case GrColorType::kRGB_565:          return "kRGB_565";
-        case GrColorType::kABGR_4444:        return "kABGR_4444";
-        case GrColorType::kRGBA_8888:        return "kRGBA_8888";
-        case GrColorType::kRGBA_8888_SRGB:   return "kRGBA_8888_SRGB";
-        case GrColorType::kRGB_888x:         return "kRGB_888x";
-        case GrColorType::kRG_88:            return "kRG_88";
-        case GrColorType::kBGRA_8888:        return "kBGRA_8888";
-        case GrColorType::kRGBA_1010102:     return "kRGBA_1010102";
-        case GrColorType::kBGRA_1010102:     return "kBGRA_1010102";
-        case GrColorType::kRGBA_10x6:        return "kBGRA_10x6";
-        case GrColorType::kGray_8:           return "kGray_8";
-        case GrColorType::kGrayAlpha_88:     return "kGrayAlpha_88";
-        case GrColorType::kAlpha_F16:        return "kAlpha_F16";
-        case GrColorType::kRGBA_F16:         return "kRGBA_F16";
-        case GrColorType::kRGBA_F16_Clamped: return "kRGBA_F16_Clamped";
-        case GrColorType::kRGBA_F32:         return "kRGBA_F32";
-        case GrColorType::kAlpha_8xxx:       return "kAlpha_8xxx";
-        case GrColorType::kAlpha_F32xxx:     return "kAlpha_F32xxx";
-        case GrColorType::kGray_8xxx:        return "kGray_8xxx";
-        case GrColorType::kR_8xxx:           return "kR_8xxx";
-        case GrColorType::kAlpha_16:         return "kAlpha_16";
-        case GrColorType::kRG_1616:          return "kRG_1616";
-        case GrColorType::kRGBA_16161616:    return "kRGBA_16161616";
-        case GrColorType::kRG_F16:           return "kRG_F16";
-        case GrColorType::kRGB_888:          return "kRGB_888";
-        case GrColorType::kR_8:              return "kR_8";
-        case GrColorType::kR_16:             return "kR_16";
-        case GrColorType::kR_F16:            return "kR_F16";
-        case GrColorType::kGray_F16:         return "kGray_F16";
-        case GrColorType::kARGB_4444:        return "kARGB_4444";
-        case GrColorType::kBGRA_4444:        return "kBGRA_4444";
-    }
-    SkUNREACHABLE;
-}
-
-static constexpr const char* GrCompressionTypeToStr(SkTextureCompressionType compression) {
-    switch (compression) {
-        case SkTextureCompressionType::kNone:            return "kNone";
-        case SkTextureCompressionType::kETC2_RGB8_UNORM: return "kETC2_RGB8_UNORM";
-        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return "kBC1_RGB8_UNORM";
-        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return "kBC1_RGBA8_UNORM";
-    }
-    SkUNREACHABLE;
-}
-
-static constexpr const char* GrSurfaceOriginToStr(GrSurfaceOrigin origin) {
-    switch (origin) {
-        case kTopLeft_GrSurfaceOrigin:    return "kTopLeft";
-        case kBottomLeft_GrSurfaceOrigin: return "kBottomLeft";
-    }
-    SkUNREACHABLE;
-}
-#endif
-
 #endif

package/cpp/skia/include/private/gpu/vk/SkiaVulkan.h

@@ -12,7 +12,7 @@
 
 // IWYU pragma: begin_exports
 
-#if (SKIA_IMPLEMENTATION || !defined(SK_VULKAN)) && !defined(SK_USE_EXTERNAL_VULKAN_HEADERS)
+#if defined(SK_USE_INTERNAL_VULKAN_HEADERS) && !defined(SK_BUILD_FOR_GOOGLE3)
 #include "include/third_party/vulkan/vulkan/vulkan_core.h"
 #else
 // For google3 builds we don't set SKIA_IMPLEMENTATION so we need to make sure that the vulkan
@@ -22,7 +22,7 @@
 
 #ifdef SK_BUILD_FOR_ANDROID
 // This is needed to get android extensions for external memory
-#if (SKIA_IMPLEMENTATION || !defined(SK_VULKAN)) && !defined(SK_USE_EXTERNAL_VULKAN_HEADERS)
+#if defined(SK_USE_INTERNAL_VULKAN_HEADERS) && !defined(SK_BUILD_FOR_GOOGLE3)
 #include "include/third_party/vulkan/vulkan/vulkan_android.h"
 #else
 // For google3 builds we don't set SKIA_IMPLEMENTATION so we need to make sure that the vulkan

package/cpp/skia/include/utils/SkCustomTypeface.h

@@ -11,6 +11,7 @@
 #include "include/core/SkDrawable.h"
 #include "include/core/SkFontMetrics.h"
 #include "include/core/SkFontStyle.h"
+#include "include/core/SkFourByteTag.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"

package/cpp/skia/include/utils/SkNWayCanvas.h

@@ -73,7 +73,7 @@ protected:
     void onDrawGlyphRunList(const sktext::GlyphRunList&, const SkPaint&) override;
     void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                         const SkPaint& paint) override;
-    void onDrawSlug(const sktext::gpu::Slug* slug) override;
+    void onDrawSlug(const sktext::gpu::Slug* slug, const SkPaint& paint) override;
     void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                      const SkPoint texCoords[4], SkBlendMode, const SkPaint& paint) override;
 

package/cpp/skia/include/utils/SkParse.h

@@ -23,7 +23,6 @@ public:
     static int Count(const char str[], char separator);
     static const char* FindColor(const char str[], SkColor* value);
     static const char* FindHex(const char str[], uint32_t* value);
-    static const char* FindMSec(const char str[], SkMSec* value);
     static const char* FindNamedColor(const char str[], size_t len, SkColor* color);
     static const char* FindS32(const char str[], int32_t* value);
     static const char* FindScalar(const char str[], SkScalar* value);

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

@@ -22,15 +22,11 @@ using U8  = V<uint8_t>;
     // GCC is kind of weird, not allowing vector = scalar directly.
     static constexpr F F0 = F() + 0.0f,
                        F1 = F() + 1.0f,
-                       FHalf = F() + 0.5f,
                        FInfBits = F() + 0x7f800000; // equals 2139095040, the bit pattern of +Inf
-    static constexpr I32 F16InfBits = I32() + 0x4780'0000;
 #else
     static constexpr F F0 = 0.0f,
                        F1 = 1.0f,
-                       FHalf = 0.5f,
                        FInfBits = 0x7f800000; // equals 2139095040, the bit pattern of +Inf
-    static constexpr I32 F16InfBits = 0x4780'0000; // equals +Inf in half float, shifted to 32-bits
 #endif
 
 // Instead of checking __AVX__ below, we'll check USING_AVX.
@@ -41,7 +37,7 @@ using U8  = V<uint8_t>;
     #define  USING_AVX
 #endif
 #if !defined(USING_AVX_F16C) && defined(USING_AVX) && defined(__F16C__)
-    #define  USING AVX_F16C
+    #define  USING_AVX_F16C
 #endif
 #if !defined(USING_AVX2)     && defined(USING_AVX) && defined(__AVX2__)
     #define  USING_AVX2
@@ -153,22 +149,7 @@ SI U32 to_fixed(F f) {  return (U32)cast<I32>(f + 0.5f); }
     }
 #endif
 
-#if defined(USING_NEON)
-    SI F min_(F x, F y) { return (F)vminq_f32((float32x4_t)x, (float32x4_t)y); }
-    SI F max_(F x, F y) { return (F)vmaxq_f32((float32x4_t)x, (float32x4_t)y); }
-
-    SI I32 min_(I32 x, I32 y) { return (I32)vminq_s32((int32x4_t)x, (int32x4_t)y); }
-    SI I32 max_(I32 x, I32 y) { return (I32)vmaxq_s32((int32x4_t)x, (int32x4_t)y); }
-#else
-    SI F min_(F x, F y) { return if_then_else(x > y, y, x); }
-    SI F max_(F x, F y) { return if_then_else(x < y, y, x); }
-
-    SI I32 min_(I32 x, I32 y) { return if_then_else(x > y, y, x); }
-    SI I32 max_(I32 x, I32 y) { return if_then_else(x < y, y, x); }
-#endif
 
-// KEEP IN SYNC with skvx::from_half to ensure that f16 colors are computed consistently in both
-// skcms and skvx.
 SI F F_from_Half(U16 half) {
 #if defined(USING_NEON_F16C)
     return vcvt_f32_f16((float16x4_t)half);
@@ -178,27 +159,24 @@ SI F F_from_Half(U16 half) {
     typedef int16_t __attribute__((vector_size(16))) I16;
     return __builtin_ia32_vcvtph2ps256((I16)half);
 #else
-    I32 wide = cast<I32>(half);
+    U32 wide = cast<U32>(half);
     // A half is 1-5-10 sign-exponent-mantissa, with 15 exponent bias.
-    // To match intrinsic behavior, this preserves denormal values, infinities, and NaNs, which
-    // helps improve consistency between architectures.
-    I32     s  = wide & 0x8000,
-            em = wide ^ s,
-    inf_or_nan = (em >= (31 << 10)) & (255 << 23), // Expands exponent to fill 8 bits
-       is_norm =  em > 0x3ff,
-           // denormalized f16's are 2^-14*0.[m0:9] == 2^-24*[m0:9].0
-           sub = bit_pun<I32>(cast<F>(em) * (1.f/(1<<24))),
-          norm = ((em<<13) + ((127-15)<<23)), // Shifts mantissa, shifts + re-biases exponent
-        finite = if_then_else(is_norm, norm, sub);
-    // If 'x' is f16 +/- infinity, inf_or_nan will be the filled 8-bit exponent but 'norm' will be
-    // all 0s since 'x's mantissa is 0. Thus norm | inf_or_nan becomes f32 infinity. However, if
-    // 'x' is an f16 NaN, some bits of 'norm' will be non-zero, so it stays an f32 NaN after the OR.
-    return bit_pun<F>((s<<16) | finite | inf_or_nan);
+    U32 s  = wide & 0x8000,
+        em = wide ^ s;
+
+    // Constructing the float is easy if the half is not denormalized.
+    F norm = bit_pun<F>( (s<<16) + (em<<13) + ((127-15)<<23) );
+
+    // Simply flush all denorm half floats to zero.
+    return if_then_else(em < 0x0400, F0, norm);
 #endif
 }
 
-// KEEP IN SYNC with skvx::to_half to ensure that f16 colors are computed consistently in both
-// skcms and skvx.
+#if defined(__clang__)
+    // The -((127-15)<<10) underflows that side of the math when
+    // we pass a denorm half float.  It's harmless... we'll take the 0 side anyway.
+    __attribute__((no_sanitize("unsigned-integer-overflow")))
+#endif
 SI U16 Half_from_F(F f) {
 #if defined(USING_NEON_F16C)
     return (U16)vcvt_f16_f32(f);
@@ -208,23 +186,13 @@ SI U16 Half_from_F(F f) {
     return (U16)__builtin_ia32_vcvtps2ph256(f, 0x04/*_MM_FROUND_CUR_DIRECTION*/);
 #else
     // A float is 1-8-23 sign-exponent-mantissa, with 127 exponent bias.
-    // To match intrinsic behavior, this implements round-to-nearest-even, converting floats to
-    // denormal f16 values, overflowing to infinity and preserving infinity. However, it does not
-    // handle NaN float values (they become infinity).
-    I32     sem = bit_pun<I32>(f),
-            s   = sem & 0x8000'0000,
-             em = min_(sem ^ s, F16InfBits), // |x| clamped to f16 infinity
-          // F(em)*8192 increases the exponent by 13, which when added back to em will shift the
-          // mantissa bits 13 to the right. We clamp to 1/2 for subnormal values, which
-          // automatically shifts the mantissa to match 2^-14 expected for a subnorm f16.
-          magic = bit_pun<I32>(max_(bit_pun<F>(em) * 8192.f, FHalf)) & (255 << 23),
-        // Shift mantissa with automatic round-to-even
-        rounded = bit_pun<I32>((bit_pun<F>(em) + bit_pun<F>(magic))),
-            // Subtract 127 for f32 bias, subtract 13 to undo the *8192, subtract 1 to remove
-            // the implicit leading 1., and add 15 to get the f16 biased exponent.
-            exp = ((magic >> 13) - ((127-15+13+1)<<10)), // shift and re-bias exponent
-            f16 = rounded + exp; // use + if 'rounded' rolled over into first exponent bit
-    return cast<U16>((s>>16) | f16);
+    U32 sem = bit_pun<U32>(f),
+        s   = sem & 0x80000000,
+         em = sem ^ s;
+
+    // For simplicity we flush denorm half floats (including all denorm floats) to zero.
+    return cast<U16>(if_then_else(em < 0x38800000, (U32)F0
+                                                 , (s>>16) + (em>>13) - ((127-15)<<10)));
 #endif
 }
 
@@ -240,6 +208,17 @@ SI U64 swap_endian_16x4(const U64& rgba) {
          | (rgba & 0xff00ff00ff00ff00) >> 8;
 }
 
+#if defined(USING_NEON)
+    SI F min_(F x, F y) { return (F)vminq_f32((float32x4_t)x, (float32x4_t)y); }
+    SI F max_(F x, F y) { return (F)vmaxq_f32((float32x4_t)x, (float32x4_t)y); }
+#elif defined(__loongarch_sx)
+    SI F min_(F x, F y) { return (F)__lsx_vfmin_s(x, y); }
+    SI F max_(F x, F y) { return (F)__lsx_vfmax_s(x, y); }
+#else
+    SI F min_(F x, F y) { return if_then_else(x > y, y, x); }
+    SI F max_(F x, F y) { return if_then_else(x < y, y, x); }
+#endif
+
 SI F floor_(F x) {
 #if N == 1
     return floorf_(x);
@@ -255,6 +234,8 @@ SI F floor_(F x) {
     return __builtin_ia32_roundps256(x, 0x01/*_MM_FROUND_FLOOR*/);
 #elif defined(__SSE4_1__)
     return _mm_floor_ps(x);
+#elif defined(__loongarch_sx)
+    return __lsx_vfrintrm_s((__m128)x);
 #else
     // Round trip through integers with a truncating cast.
     F roundtrip = cast<F>(cast<I32>(x));
@@ -668,7 +649,7 @@ SI void sample_clut_8(const uint8_t* grid_8, I32 ix, F* r, F* g, F* b, F* a) {
 }
 
 SI void sample_clut_16(const uint8_t* grid_16, I32 ix, F* r, F* g, F* b) {
-#if defined(__arm__)
+#if defined(__arm__) || defined(__loongarch_sx)
     // This is up to 2x faster on 32-bit ARM than the #else-case fast path.
     *r = F_from_U16_BE(gather_16(grid_16, 3*ix+0));
     *g = F_from_U16_BE(gather_16(grid_16, 3*ix+1));
@@ -856,6 +837,12 @@ STAGE(load_g8, NoCtx) {
     r = g = b = F_from_U8(load<U8>(src + 1*i));
 }
 
+STAGE(load_ga88, NoCtx) {
+    U16 u16 = load<U16>(src + 2 * i);
+    r = g = b = cast<F>((u16 >> 0) & 0xff) * (1 / 255.0f);
+            a = cast<F>((u16 >> 8) & 0xff) * (1 / 255.0f);
+}
+
 STAGE(load_4444, NoCtx) {
     U16 abgr = load<U16>(src + 2*i);
 
@@ -926,6 +913,17 @@ STAGE(load_101010x_XR, NoCtx) {
     b = cast<F>((rgba >> 20) & 0x3ff) * (1/1023.0f) * range + min;
 }
 
+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;
+}
+
 STAGE(load_161616LE, NoCtx) {
     uintptr_t ptr = (uintptr_t)(src + 6*i);
     assert( (ptr & 1) == 0 );                   // src must be 2-byte aligned for this
@@ -1263,6 +1261,12 @@ FINAL_STAGE(store_g8, NoCtx) {
     store(dst + 1*i, cast<U8>(to_fixed(g * 255)));
 }
 
+FINAL_STAGE(store_ga88, NoCtx) {
+    // g should be holding luminance (Y) (r,g,b ~~~> X,Y,Z)
+    store<U16>(dst + 2*i, cast<U16>(to_fixed(g * 255) << 0 )
+                        | cast<U16>(to_fixed(a * 255) << 8 ));
+}
+
 FINAL_STAGE(store_4444, NoCtx) {
     store<U16>(dst + 2*i, cast<U16>(to_fixed(r * 15) << 12)
                         | cast<U16>(to_fixed(g * 15) <<  8)
@@ -1312,7 +1316,6 @@ FINAL_STAGE(store_101010x_XR, NoCtx) {
     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);
-    return;
 }
 
 FINAL_STAGE(store_1010102, NoCtx) {

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

@@ -20,12 +20,14 @@ namespace skcms_private {
 #define SKCMS_WORK_OPS(M) \
     M(load_a8)            \
     M(load_g8)            \
+    M(load_ga88)          \
     M(load_4444)          \
     M(load_565)           \
     M(load_888)           \
     M(load_8888)          \
     M(load_1010102)       \
     M(load_101010x_XR)    \
+    M(load_10101010_XR)   \
     M(load_161616LE)      \
     M(load_16161616LE)    \
     M(load_161616BE)      \
@@ -88,6 +90,7 @@ namespace skcms_private {
 #define SKCMS_STORE_OPS(M) \
     M(store_a8)            \
     M(store_g8)            \
+    M(store_ga88)          \
     M(store_4444)          \
     M(store_565)           \
     M(store_888)           \

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

@@ -39,6 +39,7 @@ extern "C" {
         // - Clang 18 runs into an ICE on armv7/androideabi with [[clang::musttail]].
         //   (http://crbug.com/1504548)
         // - Android RISC-V also runs into an ICE (b/314692534)
+        // - LoongArch developers indicate they had to turn it off
         // - Windows builds generate incorrect code with [[clang::musttail]] and crash mysteriously.
         //   (http://crbug.com/1505442)
         #if __has_cpp_attribute(clang::musttail) && !__has_feature(memory_sanitizer) \
@@ -46,6 +47,7 @@ extern "C" {
                                                  && !defined(__EMSCRIPTEN__) \
                                                  && !defined(__arm__) \
                                                  && !defined(__riscv) \
+                                                 && !defined(__loongarch__) \
                                                  && !defined(_WIN32) && !defined(__SYMBIAN32__)
             #define SKCMS_HAS_MUSTTAIL 1
         #endif

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

@@ -258,16 +258,44 @@ SKCMS_API bool skcms_ApproximateCurve(const skcms_Curve* curve,
 SKCMS_API bool skcms_GetCHAD(const skcms_ICCProfile*, skcms_Matrix3x3*);
 SKCMS_API bool skcms_GetWTPT(const skcms_ICCProfile*, float xyz[3]);
 
+// Returns the number of channels of input data that are expected on the "A" side of the profile.
+// This is useful for image codecs, where the image data and the accompanying profile might have
+// conflicting data shapes. In some cases, the result is unclear or invalid. In that case, the
+// function will return a negative value to signal an error.
+SKCMS_API int skcms_GetInputChannelCount(const skcms_ICCProfile*);
+
 // These are common ICC signature values
 enum {
-    // data_color_space
+    // common data_color_space values
     skcms_Signature_CMYK = 0x434D594B,
     skcms_Signature_Gray = 0x47524159,
     skcms_Signature_RGB  = 0x52474220,
 
-    // pcs
+    // pcs (or data_color_space)
     skcms_Signature_Lab  = 0x4C616220,
     skcms_Signature_XYZ  = 0x58595A20,
+
+    // other, less common data_color_space values
+    skcms_Signature_CIELUV = 0x4C757620,
+    skcms_Signature_YCbCr  = 0x59436272,
+    skcms_Signature_CIEYxy = 0x59787920,
+    skcms_Signature_HSV    = 0x48535620,
+    skcms_Signature_HLS    = 0x484C5320,
+    skcms_Signature_CMY    = 0x434D5920,
+    skcms_Signature_2CLR   = 0x32434C52,
+    skcms_Signature_3CLR   = 0x33434C52,
+    skcms_Signature_4CLR   = 0x34434C52,
+    skcms_Signature_5CLR   = 0x35434C52,
+    skcms_Signature_6CLR   = 0x36434C52,
+    skcms_Signature_7CLR   = 0x37434C52,
+    skcms_Signature_8CLR   = 0x38434C52,
+    skcms_Signature_9CLR   = 0x39434C52,
+    skcms_Signature_10CLR  = 0x41434C52,
+    skcms_Signature_11CLR  = 0x42434C52,
+    skcms_Signature_12CLR  = 0x43434C52,
+    skcms_Signature_13CLR  = 0x44434C52,
+    skcms_Signature_14CLR  = 0x45434C52,
+    skcms_Signature_15CLR  = 0x46434C52,
 };
 
 typedef enum skcms_PixelFormat {
@@ -275,6 +303,8 @@ typedef enum skcms_PixelFormat {
     skcms_PixelFormat_A_8_,
     skcms_PixelFormat_G_8,
     skcms_PixelFormat_G_8_,
+    skcms_PixelFormat_GA_88,  // Grayscale with alpha.
+    skcms_PixelFormat_GA_88_,
 
     skcms_PixelFormat_RGB_565,
     skcms_PixelFormat_BGR_565,
@@ -286,39 +316,41 @@ typedef enum skcms_PixelFormat {
     skcms_PixelFormat_BGR_888,
     skcms_PixelFormat_RGBA_8888,
     skcms_PixelFormat_BGRA_8888,
-    skcms_PixelFormat_RGBA_8888_sRGB,   // Automatic sRGB encoding / decoding.
-    skcms_PixelFormat_BGRA_8888_sRGB,   // (Generally used with linear transfer functions.)
+    skcms_PixelFormat_RGBA_8888_sRGB,  // Automatic sRGB encoding / decoding.
+    skcms_PixelFormat_BGRA_8888_sRGB,  // (Generally used with linear transfer functions.)
 
     skcms_PixelFormat_RGBA_1010102,
     skcms_PixelFormat_BGRA_1010102,
 
-    skcms_PixelFormat_RGB_161616LE,     // Little-endian.  Pointers must be 16-bit aligned.
+    skcms_PixelFormat_RGB_161616LE,  // Little-endian.  Pointers must be 16-bit aligned.
     skcms_PixelFormat_BGR_161616LE,
     skcms_PixelFormat_RGBA_16161616LE,
     skcms_PixelFormat_BGRA_16161616LE,
 
-    skcms_PixelFormat_RGB_161616BE,     // Big-endian.  Pointers must be 16-bit aligned.
+    skcms_PixelFormat_RGB_161616BE,  // Big-endian.  Pointers must be 16-bit aligned.
     skcms_PixelFormat_BGR_161616BE,
     skcms_PixelFormat_RGBA_16161616BE,
     skcms_PixelFormat_BGRA_16161616BE,
 
-    skcms_PixelFormat_RGB_hhh_Norm,   // 1-5-10 half-precision float in [0,1]
-    skcms_PixelFormat_BGR_hhh_Norm,   // Pointers must be 16-bit aligned.
+    skcms_PixelFormat_RGB_hhh_Norm,  // 1-5-10 half-precision float in [0,1]
+    skcms_PixelFormat_BGR_hhh_Norm,  // Pointers must be 16-bit aligned.
     skcms_PixelFormat_RGBA_hhhh_Norm,
     skcms_PixelFormat_BGRA_hhhh_Norm,
 
-    skcms_PixelFormat_RGB_hhh,        // 1-5-10 half-precision float.
-    skcms_PixelFormat_BGR_hhh,        // Pointers must be 16-bit aligned.
+    skcms_PixelFormat_RGB_hhh,  // 1-5-10 half-precision float.
+    skcms_PixelFormat_BGR_hhh,  // Pointers must be 16-bit aligned.
     skcms_PixelFormat_RGBA_hhhh,
     skcms_PixelFormat_BGRA_hhhh,
 
-    skcms_PixelFormat_RGB_fff,        // 1-8-23 single-precision float (the normal kind).
-    skcms_PixelFormat_BGR_fff,        // Pointers must be 32-bit aligned.
+    skcms_PixelFormat_RGB_fff,  // 1-8-23 single-precision float (the normal kind).
+    skcms_PixelFormat_BGR_fff,  // Pointers must be 32-bit aligned.
     skcms_PixelFormat_RGBA_ffff,
     skcms_PixelFormat_BGRA_ffff,
 
-    skcms_PixelFormat_RGB_101010x_XR,  // Note: This is located here to signal no clamping.
-    skcms_PixelFormat_BGR_101010x_XR,  // Compatible with MTLPixelFormatBGR10_XR.
+    skcms_PixelFormat_RGB_101010x_XR,    // Note: This is located here to signal no clamping.
+    skcms_PixelFormat_BGR_101010x_XR,    // Compatible with MTLPixelFormatBGR10_XR.
+    skcms_PixelFormat_RGBA_10101010_XR,  // Note: This is located here to signal no clamping.
+    skcms_PixelFormat_BGRA_10101010_XR,  // Compatible with MTLPixelFormatBGRA10_XR.
 } skcms_PixelFormat;
 
 // We always store any alpha channel linearly.  In the chart below, tf-1() is the inverse