@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -8,133 +8,8 @@
 #ifndef GrVkMemoryAllocator_DEFINED
 #define GrVkMemoryAllocator_DEFINED
 
-#include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
-#include "include/gpu/vk/GrVkTypes.h"
+#include "include/gpu/vk/VulkanMemoryAllocator.h"
 
-class GrVkMemoryAllocator : public SkRefCnt {
-public:
-    enum class AllocationPropertyFlags {
-        kNone                = 0,
-        // Allocation will be placed in its own VkDeviceMemory and not suballocated from some larger
-        // block.
-        kDedicatedAllocation = 0x1,
-        // Says that the backing memory can only be accessed by the device. Additionally the device
-        // may lazily allocate the memory. This cannot be used with buffers that will be host
-        // visible. Setting this flag does not guarantee that we will allocate memory that respects
-        // it, but we will try to prefer memory that can respect it.
-        kLazyAllocation      = 0x2,
-        // The allocation will be mapped immediately and stay mapped until it is destroyed. This
-        // flag is only valid for buffers which are host visible (i.e. must have a usage other than
-        // BufferUsage::kGpuOnly).
-        kPersistentlyMapped  = 0x4,
-        // Allocation can only be accessed by the device using a protected context.
-        kProtected  = 0x8,
-    };
-
-    GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(AllocationPropertyFlags);
-
-    enum class BufferUsage {
-        // Buffers that will only be accessed from the device (large const buffers). Will always be
-        // in device local memory.
-        kGpuOnly,
-        // Buffers that typically will be updated multiple times by the host and read on the gpu
-        // (e.g. uniform or vertex buffers). CPU writes will generally be sequential in the buffer
-        // and will try to take advantage of the write-combined nature of the gpu buffers. Thus this
-        // will always be mappable and coherent memory, and it will prefer to be in device local
-        // memory.
-        kCpuWritesGpuReads,
-        // Buffers that will be accessed on the host and copied to another GPU resource (transfer
-        // buffers). Will always be mappable and coherent memory.
-        kTransfersFromCpuToGpu,
-        // Buffers which are typically writted to by the GPU and then read on the host. Will always
-        // be mappable memory, and will prefer cached memory.
-        kTransfersFromGpuToCpu,
-    };
-
-    // DEPRECATED: Use and implement allocateImageMemory instead
-    virtual bool allocateMemoryForImage(VkImage, AllocationPropertyFlags, GrVkBackendMemory*) {
-        // The default implementation here is so clients can delete this virtual as the switch to
-        // the new one which returns a VkResult.
-        return false;
-    }
-
-    virtual VkResult allocateImageMemory(VkImage image, AllocationPropertyFlags flags,
-                                         GrVkBackendMemory* memory) {
-        bool result = this->allocateMemoryForImage(image, flags, memory);
-        // VK_ERROR_INITIALIZATION_FAILED is a bogus result to return from this function, but it is
-        // just something to return that is not VK_SUCCESS and can't be interpreted by a caller to
-        // mean something specific happened like device lost or oom. This will be removed once we
-        // update clients to implement this virtual.
-        return result ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    // DEPRECATED: Use and implement allocateBufferMemory instead
-    virtual bool allocateMemoryForBuffer(VkBuffer, BufferUsage,  AllocationPropertyFlags,
-                                         GrVkBackendMemory*) {
-        // The default implementation here is so clients can delete this virtual as the switch to
-        // the new one which returns a VkResult.
-        return false;
-    }
-
-    virtual VkResult allocateBufferMemory(VkBuffer buffer,
-                                          BufferUsage usage,
-                                          AllocationPropertyFlags flags,
-                                          GrVkBackendMemory* memory) {
-        bool result = this->allocateMemoryForBuffer(buffer, usage, flags, memory);
-        // VK_ERROR_INITIALIZATION_FAILED is a bogus result to return from this function, but it is
-        // just something to return that is not VK_SUCCESS and can't be interpreted by a caller to
-        // mean something specific happened like device lost or oom. This will be removed once we
-        // update clients to implement this virtual.
-        return result ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-
-    // Fills out the passed in GrVkAlloc struct for the passed in GrVkBackendMemory.
-    virtual void getAllocInfo(const GrVkBackendMemory&, GrVkAlloc*) const = 0;
-
-    // Maps the entire allocation and returns a pointer to the start of the allocation. The
-    // implementation may map more memory than just the allocation, but the returned pointer must
-    // point at the start of the memory for the requested allocation.
-    virtual void* mapMemory(const GrVkBackendMemory&) { return nullptr; }
-    virtual VkResult mapMemory(const GrVkBackendMemory& memory, void** data) {
-        *data = this->mapMemory(memory);
-        // VK_ERROR_INITIALIZATION_FAILED is a bogus result to return from this function, but it is
-        // just something to return that is not VK_SUCCESS and can't be interpreted by a caller to
-        // mean something specific happened like device lost or oom. This will be removed once we
-        // update clients to implement this virtual.
-        return *data ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED;
-    }
-    virtual void unmapMemory(const GrVkBackendMemory&) = 0;
-
-    // The following two calls are used for managing non-coherent memory. The offset is relative to
-    // the start of the allocation and not the underlying VkDeviceMemory. Additionaly the client
-    // must make sure that the offset + size passed in is less that or equal to the allocation size.
-    // It is the responsibility of the implementation to make sure all alignment requirements are
-    // followed. The client should not have to deal with any sort of alignment issues.
-    virtual void flushMappedMemory(const GrVkBackendMemory&, VkDeviceSize, VkDeviceSize) {}
-    virtual VkResult flushMemory(const GrVkBackendMemory& memory,  VkDeviceSize offset,
-                                 VkDeviceSize size) {
-        this->flushMappedMemory(memory, offset, size);
-        return VK_SUCCESS;
-    }
-    virtual void invalidateMappedMemory(const GrVkBackendMemory&, VkDeviceSize, VkDeviceSize) {}
-    virtual VkResult invalidateMemory(const GrVkBackendMemory& memory,  VkDeviceSize offset,
-                                 VkDeviceSize size) {
-        this->invalidateMappedMemory(memory, offset, size);
-        return VK_SUCCESS;
-    }
-
-    virtual void freeMemory(const GrVkBackendMemory&) = 0;
-
-    // Returns the total amount of memory that is allocated and in use by an allocation for this
-    // allocator.
-    virtual uint64_t totalUsedMemory() const = 0;
-
-    // Returns the total amount of memory that is allocated by this allocator.
-    virtual uint64_t totalAllocatedMemory() const = 0;
-};
-
-GR_MAKE_BITFIELD_CLASS_OPS(GrVkMemoryAllocator::AllocationPropertyFlags)
+using GrVkMemoryAllocator = skgpu::VulkanMemoryAllocator;
 
 #endif

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

@@ -9,45 +9,11 @@
 #ifndef GrVkTypes_DEFINED
 #define GrVkTypes_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/gpu/vk/GrVkVulkan.h"
-
-#ifndef VK_VERSION_1_1
-#error Skia requires the use of Vulkan 1.1 headers
-#endif
-
-#include <functional>
 #include "include/gpu/GrTypes.h"
+#include "include/gpu/vk/VulkanTypes.h"
 
-typedef intptr_t GrVkBackendMemory;
-
-/**
- * Types for interacting with Vulkan resources created externally to Skia. GrBackendObjects for
- * Vulkan textures are really const GrVkImageInfo*
- */
-struct GrVkAlloc {
-    // can be VK_NULL_HANDLE iff is an RT and is borrowed
-    VkDeviceMemory    fMemory = VK_NULL_HANDLE;
-    VkDeviceSize      fOffset = 0;
-    VkDeviceSize      fSize = 0;  // this can be indeterminate iff Tex uses borrow semantics
-    uint32_t          fFlags = 0;
-    GrVkBackendMemory fBackendMemory = 0; // handle to memory allocated via GrVkMemoryAllocator.
-
-    enum Flag {
-        kNoncoherent_Flag     = 0x1,   // memory must be flushed to device after mapping
-        kMappable_Flag        = 0x2,   // memory is able to be mapped.
-        kLazilyAllocated_Flag = 0x4,   // memory was created with lazy allocation
-    };
-
-    bool operator==(const GrVkAlloc& that) const {
-        return fMemory == that.fMemory && fOffset == that.fOffset && fSize == that.fSize &&
-               fFlags == that.fFlags && fUsesSystemHeap == that.fUsesSystemHeap;
-    }
-
-private:
-    friend class GrVkHeap; // For access to usesSystemHeap
-    bool fUsesSystemHeap = false;
-};
+using GrVkBackendMemory = skgpu::VulkanBackendMemory;
+using GrVkAlloc = skgpu::VulkanAlloc;
 
 // This struct is used to pass in the necessary information to create a VkSamplerYcbcrConversion
 // object for an VkExternalFormatANDROID.
@@ -98,7 +64,7 @@ struct GrVkYcbcrConversionInfo {
  */
 struct GrVkImageInfo {
     VkImage                  fImage = VK_NULL_HANDLE;
-    GrVkAlloc                fAlloc;
+    skgpu::VulkanAlloc       fAlloc;
     VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
     VkImageLayout            fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
     VkFormat                 fFormat = VK_FORMAT_UNDEFINED;
@@ -134,11 +100,7 @@ struct GrVkImageInfo {
 #endif
 };
 
-using GrVkGetProc = std::function<PFN_vkVoidFunction(
-        const char*, // function name
-        VkInstance,  // instance or VK_NULL_HANDLE
-        VkDevice     // device or VK_NULL_HANDLE
-        )>;
+using GrVkGetProc = skgpu::VulkanGetProc;
 
 /**
  * This object is wrapped in a GrBackendDrawableInfo and passed in as an argument to

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

@@ -0,0 +1,46 @@
+/*
+ * 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 skgpu_VulkanBackendContext_DEFINED
+#define skgpu_VulkanBackendContext_DEFINED
+
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/vk/VulkanMemoryAllocator.h"
+#include "include/gpu/vk/VulkanTypes.h"
+
+namespace skgpu {
+
+class VulkanExtensions;
+
+// The VkBackendContext contains all of the base Vk objects needed by the skia Vulkan context.
+struct SK_API VulkanBackendContext {
+    VkInstance                       fInstance;
+    VkPhysicalDevice                 fPhysicalDevice;
+    VkDevice                         fDevice;
+    VkQueue                          fQueue;
+    uint32_t                         fGraphicsQueueIndex;
+    // The max api version set here should match the value set in VkApplicationInfo::apiVersion when
+    // then VkInstance was created.
+    uint32_t                         fMaxAPIVersion;
+    const skgpu::VulkanExtensions*   fVkExtensions = nullptr;
+    // The client can create their VkDevice with either a VkPhysicalDeviceFeatures or
+    // VkPhysicalDeviceFeatures2 struct, thus we have to support taking both. The
+    // VkPhysicalDeviceFeatures2 struct is needed so we know if the client enabled any extension
+    // specific features. If fDeviceFeatures2 is not null then we ignore fDeviceFeatures. If both
+    // fDeviceFeatures and fDeviceFeatures2 are null we will assume no features are enabled.
+    const VkPhysicalDeviceFeatures*  fDeviceFeatures = nullptr;
+    const VkPhysicalDeviceFeatures2* fDeviceFeatures2 = nullptr;
+    // Optional. The client may provide an inplementation of a VulkanMemoryAllocator for Skia to use
+    // for allocating Vulkan resources that use VkDeviceMemory.
+    sk_sp<VulkanMemoryAllocator>     fMemoryAllocator;
+    skgpu::VulkanGetProc             fGetProc;
+    Protected                        fProtectedContext;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_VulkanBackendContext_DEFINED

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

@@ -0,0 +1,67 @@
+/*
+ * 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 skgpu_VulkanExtensions_DEFINED
+#define skgpu_VulkanExtensions_DEFINED
+
+#include "include/core/SkString.h"
+#include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/SkTArray.h"
+
+namespace skgpu {
+
+/**
+ * Helper class that eats in an array of extensions strings for instance and device and allows for
+ * quicker querying if an extension is present.
+ */
+class SK_API VulkanExtensions {
+public:
+    VulkanExtensions() {}
+
+    void init(VulkanGetProc, VkInstance, VkPhysicalDevice,
+              uint32_t instanceExtensionCount, const char* const* instanceExtensions,
+              uint32_t deviceExtensionCount, const char* const* deviceExtensions);
+
+    bool hasExtension(const char[], uint32_t minVersion) const;
+
+    struct Info {
+        Info() {}
+        Info(const char* name) : fName(name), fSpecVersion(0) {}
+
+        SkString fName;
+        uint32_t fSpecVersion;
+
+        struct Less {
+            bool operator()(const Info& a, const SkString& b) const {
+                return strcmp(a.fName.c_str(), b.c_str()) < 0;
+            }
+            bool operator()(const SkString& a, const VulkanExtensions::Info& b) const {
+                return strcmp(a.c_str(), b.fName.c_str()) < 0;
+            }
+        };
+    };
+
+#ifdef SK_DEBUG
+    void dump() const {
+        SkDebugf("**Vulkan Extensions**\n");
+        for (int i = 0; i < fExtensions.count(); ++i) {
+            SkDebugf("%s. Version: %d\n",
+                     fExtensions[i].fName.c_str(), fExtensions[i].fSpecVersion);
+        }
+        SkDebugf("**End Vulkan Extensions**\n");
+    }
+#endif
+
+private:
+    void getSpecVersions(VulkanGetProc getProc, VkInstance, VkPhysicalDevice);
+
+    SkTArray<Info> fExtensions;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanExtensions_DEFINED

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

@@ -0,0 +1,116 @@
+/*
+ * 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 skgpu_VulkanMemoryAllocator_DEFINED
+#define skgpu_VulkanMemoryAllocator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/vk/VulkanTypes.h"
+
+namespace skgpu {
+
+class VulkanMemoryAllocator : public SkRefCnt {
+public:
+    enum AllocationPropertyFlags {
+        kNone_AllocationPropertyFlag                = 0b0000,
+        // Allocation will be placed in its own VkDeviceMemory and not suballocated from some larger
+        // block.
+        kDedicatedAllocation_AllocationPropertyFlag = 0b0001,
+        // Says that the backing memory can only be accessed by the device. Additionally the device
+        // may lazily allocate the memory. This cannot be used with buffers that will be host
+        // visible. Setting this flag does not guarantee that we will allocate memory that respects
+        // it, but we will try to prefer memory that can respect it.
+        kLazyAllocation_AllocationPropertyFlag      = 0b0010,
+        // The allocation will be mapped immediately and stay mapped until it is destroyed. This
+        // flag is only valid for buffers which are host visible (i.e. must have a usage other than
+        // BufferUsage::kGpuOnly).
+        kPersistentlyMapped_AllocationPropertyFlag  = 0b0100,
+        // Allocation can only be accessed by the device using a protected context.
+        kProtected_AllocationPropertyFlag           = 0b1000,
+    };
+
+    enum class BufferUsage {
+        // Buffers that will only be accessed from the device (large const buffers). Will always be
+        // in device local memory.
+        kGpuOnly,
+        // Buffers that typically will be updated multiple times by the host and read on the gpu
+        // (e.g. uniform or vertex buffers). CPU writes will generally be sequential in the buffer
+        // and will try to take advantage of the write-combined nature of the gpu buffers. Thus this
+        // will always be mappable and coherent memory, and it will prefer to be in device local
+        // memory.
+        kCpuWritesGpuReads,
+        // Buffers that will be accessed on the host and copied to another GPU resource (transfer
+        // buffers). Will always be mappable and coherent memory.
+        kTransfersFromCpuToGpu,
+        // Buffers which are typically writted to by the GPU and then read on the host. Will always
+        // be mappable memory, and will prefer cached memory.
+        kTransfersFromGpuToCpu,
+    };
+
+    virtual VkResult allocateImageMemory(VkImage image,
+                                         uint32_t allocationPropertyFlags,
+                                         skgpu::VulkanBackendMemory* memory) = 0;
+
+    virtual VkResult allocateBufferMemory(VkBuffer buffer,
+                                          BufferUsage usage,
+                                          uint32_t allocationPropertyFlags,
+                                          skgpu::VulkanBackendMemory* memory) = 0;
+
+    // Fills out the passed in skgpu::VulkanAlloc struct for the passed in
+    // skgpu::VulkanBackendMemory.
+    virtual void getAllocInfo(const skgpu::VulkanBackendMemory&, skgpu::VulkanAlloc*) const = 0;
+
+    // Maps the entire allocation and returns a pointer to the start of the allocation. The
+    // implementation may map more memory than just the allocation, but the returned pointer must
+    // point at the start of the memory for the requested allocation.
+    virtual void* mapMemory(const skgpu::VulkanBackendMemory&) { return nullptr; }
+    virtual VkResult mapMemory(const skgpu::VulkanBackendMemory& memory, void** data) {
+        *data = this->mapMemory(memory);
+        // VK_ERROR_INITIALIZATION_FAILED is a bogus result to return from this function, but it is
+        // just something to return that is not VK_SUCCESS and can't be interpreted by a caller to
+        // mean something specific happened like device lost or oom. This will be removed once we
+        // update clients to implement this virtual.
+        return *data ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED;
+    }
+    virtual void unmapMemory(const skgpu::VulkanBackendMemory&) = 0;
+
+    // The following two calls are used for managing non-coherent memory. The offset is relative to
+    // the start of the allocation and not the underlying VkDeviceMemory. Additionaly the client
+    // must make sure that the offset + size passed in is less that or equal to the allocation size.
+    // It is the responsibility of the implementation to make sure all alignment requirements are
+    // followed. The client should not have to deal with any sort of alignment issues.
+    virtual void flushMappedMemory(const skgpu::VulkanBackendMemory&, VkDeviceSize, VkDeviceSize) {}
+    virtual VkResult flushMemory(const skgpu::VulkanBackendMemory& memory,
+                                 VkDeviceSize offset,
+                                 VkDeviceSize size) {
+        this->flushMappedMemory(memory, offset, size);
+        return VK_SUCCESS;
+    }
+    virtual void invalidateMappedMemory(const skgpu::VulkanBackendMemory&,
+                                        VkDeviceSize,
+                                        VkDeviceSize) {}
+    virtual VkResult invalidateMemory(const skgpu::VulkanBackendMemory& memory,
+                                      VkDeviceSize offset,
+                                      VkDeviceSize size) {
+        this->invalidateMappedMemory(memory, offset, size);
+        return VK_SUCCESS;
+    }
+
+    virtual void freeMemory(const skgpu::VulkanBackendMemory&) = 0;
+
+    // Returns the total amount of memory that is allocated and in use by an allocation for this
+    // allocator.
+    virtual uint64_t totalUsedMemory() const = 0;
+
+    // Returns the total amount of memory that is allocated by this allocator.
+    virtual uint64_t totalAllocatedMemory() const = 0;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanMemoryAllocator_DEFINED

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

@@ -0,0 +1,59 @@
+/*
+ * 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 skgpu_VulkanTypes_DEFINED
+#define skgpu_VulkanTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <functional>
+
+#ifndef VK_VERSION_1_1
+#error Skia requires the use of Vulkan 1.1 headers
+#endif
+
+namespace skgpu {
+
+using VulkanGetProc = std::function<PFN_vkVoidFunction(
+        const char*, // function name
+        VkInstance,  // instance or VK_NULL_HANDLE
+        VkDevice     // device or VK_NULL_HANDLE
+        )>;
+
+typedef intptr_t VulkanBackendMemory;
+
+/**
+ * Types for interacting with Vulkan resources created externally to Skia.
+ */
+struct VulkanAlloc {
+    // can be VK_NULL_HANDLE iff is an RT and is borrowed
+    VkDeviceMemory      fMemory = VK_NULL_HANDLE;
+    VkDeviceSize        fOffset = 0;
+    VkDeviceSize        fSize = 0;  // this can be indeterminate iff Tex uses borrow semantics
+    uint32_t            fFlags = 0;
+    // handle to memory allocated via skgpu::VulkanMemoryAllocator.
+    VulkanBackendMemory fBackendMemory = 0;
+
+    enum Flag {
+        kNoncoherent_Flag     = 0x1,   // memory must be flushed to device after mapping
+        kMappable_Flag        = 0x2,   // memory is able to be mapped.
+        kLazilyAllocated_Flag = 0x4,   // memory was created with lazy allocation
+    };
+
+    bool operator==(const VulkanAlloc& that) const {
+        return fMemory == that.fMemory && fOffset == that.fOffset && fSize == that.fSize &&
+               fFlags == that.fFlags && fUsesSystemHeap == that.fUsesSystemHeap;
+    }
+
+private:
+    bool fUsesSystemHeap = false;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanTypes_DEFINED

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

@@ -7,11 +7,11 @@
 #ifndef SkPathOps_DEFINED
 #define SkPathOps_DEFINED
 
+#include "include/core/SkPath.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkTArray.h"
 #include "include/private/SkTDArray.h"
 
-class SkPath;
 struct SkRect;
 
 

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

@@ -10,8 +10,8 @@
 
 #include "include/core/SkColor.h"
 #include "include/core/SkColorPriv.h"
-#include "include/private/SkNx.h"
 #include "include/private/SkTo.h"
+#include "include/private/SkVx.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Convert a 16bit pixel to a 32bit pixel
@@ -330,27 +330,6 @@ static inline U16CPU SkPack888ToRGB16(U8CPU r, U8CPU g, U8CPU b) {
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-/*  SrcOver the 32bit src color with the 16bit dst, returning a 16bit value
-    (with dirt in the high 16bits, so caller beware).
-*/
-static inline U16CPU SkSrcOver32To16(SkPMColor src, uint16_t dst) {
-    unsigned sr = SkGetPackedR32(src);
-    unsigned sg = SkGetPackedG32(src);
-    unsigned sb = SkGetPackedB32(src);
-
-    unsigned dr = SkGetPackedR16(dst);
-    unsigned dg = SkGetPackedG16(dst);
-    unsigned db = SkGetPackedB16(dst);
-
-    unsigned isa = 255 - SkGetPackedA32(src);
-
-    dr = (sr + SkMul16ShiftRound(dr, isa, SK_R16_BITS)) >> (8 - SK_R16_BITS);
-    dg = (sg + SkMul16ShiftRound(dg, isa, SK_G16_BITS)) >> (8 - SK_G16_BITS);
-    db = (sb + SkMul16ShiftRound(db, isa, SK_B16_BITS)) >> (8 - SK_B16_BITS);
-
-    return SkPackRGB16(dr, dg, db);
-}
-
 static inline SkColor SkPixel16ToColor(U16CPU src) {
     SkASSERT(src == SkToU16(src));
 
@@ -395,11 +374,11 @@ static inline SkPMColor SkPixel4444ToPixel32(U16CPU c) {
     return d | (d << 4);
 }
 
-static inline Sk4f swizzle_rb(const Sk4f& x) {
-    return SkNx_shuffle<2, 1, 0, 3>(x);
+static inline skvx::float4 swizzle_rb(const skvx::float4& x) {
+    return skvx::shuffle<2, 1, 0, 3>(x);
 }
 
-static inline Sk4f swizzle_rb_if_bgra(const Sk4f& x) {
+static inline skvx::float4 swizzle_rb_if_bgra(const skvx::float4& x) {
 #ifdef SK_PMCOLOR_IS_BGRA
     return swizzle_rb(x);
 #else
@@ -407,24 +386,15 @@ static inline Sk4f swizzle_rb_if_bgra(const Sk4f& x) {
 #endif
 }
 
-static inline Sk4f Sk4f_fromL32(uint32_t px) {
-    return SkNx_cast<float>(Sk4b::Load(&px)) * (1 / 255.0f);
+static inline skvx::float4 Sk4f_fromL32(uint32_t px) {
+    return skvx::cast<float>(skvx::byte4::Load(&px)) * (1 / 255.0f);
 }
 
-static inline uint32_t Sk4f_toL32(const Sk4f& px) {
-    Sk4f v = px;
-
-#if !defined(SKNX_NO_SIMD) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
-    // SkNx_cast<uint8_t, int32_t>() pins, and we don't anticipate giant floats
-#elif !defined(SKNX_NO_SIMD) && defined(SK_ARM_HAS_NEON)
-    // SkNx_cast<uint8_t, int32_t>() pins, and so does Sk4f_round().
-#else
-    // No guarantee of a pin.
-    v = Sk4f::Max(0, Sk4f::Min(v, 1));
-#endif
-
+static inline uint32_t Sk4f_toL32(const skvx::float4& px) {
     uint32_t l32;
-    SkNx_cast<uint8_t>(Sk4f_round(v * 255.0f)).store(&l32);
+    // For the expected positive color values, the +0.5 before the pin and cast effectively rounds
+    // to the nearest int without having to call round() or lrint().
+    skvx::cast<uint8_t>(pin(px * 255.f + 0.5f, skvx::float4(0.f), skvx::float4(255.f))).store(&l32);
     return l32;
 }
 

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

@@ -8,12 +8,18 @@
 #ifndef SkEncodedInfo_DEFINED
 #define SkEncodedInfo_DEFINED
 
-#include <memory>
-
+#include "include/core/SkAlphaType.h"
 #include "include/core/SkColorSpace.h"
+#include "include/core/SkColorType.h"
 #include "include/core/SkData.h"
 #include "include/core/SkImageInfo.h"
-#include "include/third_party/skcms/skcms.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "modules/skcms/skcms.h"
+
+#include <cstdint>
+#include <memory>
+#include <utility>
 
 struct SkEncodedInfo {
 public:

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

@@ -57,7 +57,10 @@ constexpr float sk_float_radians_to_degrees(float radians) {
     return radians * (180 / SK_FloatPI);
 }
 
-#define sk_float_round(x) sk_float_floor((x) + 0.5f)
+// 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))
 
 // can't find log2f on android, but maybe that just a tool bug?
 #ifdef SK_BUILD_FOR_ANDROID
@@ -130,19 +133,19 @@ static inline int64_t sk_float_saturate2int64(float x) {
 }
 
 #define sk_float_floor2int(x)   sk_float_saturate2int(sk_float_floor(x))
-#define sk_float_round2int(x)   sk_float_saturate2int(sk_float_floor((x) + 0.5f))
+#define sk_float_round2int(x)   sk_float_saturate2int(sk_float_round(x))
 #define sk_float_ceil2int(x)    sk_float_saturate2int(sk_float_ceil(x))
 
 #define sk_float_floor2int_no_saturate(x)   (int)sk_float_floor(x)
-#define sk_float_round2int_no_saturate(x)   (int)sk_float_floor((x) + 0.5f)
+#define sk_float_round2int_no_saturate(x)   (int)sk_float_round(x)
 #define sk_float_ceil2int_no_saturate(x)    (int)sk_float_ceil(x)
 
 #define sk_double_floor(x)          floor(x)
 #define sk_double_round(x)          floor((x) + 0.5)
 #define sk_double_ceil(x)           ceil(x)
-#define sk_double_floor2int(x)      (int)floor(x)
-#define sk_double_round2int(x)      (int)floor((x) + 0.5)
-#define sk_double_ceil2int(x)       (int)ceil(x)
+#define sk_double_floor2int(x)      (int)sk_double_floor(x)
+#define sk_double_round2int(x)      (int)sk_double_round(x)
+#define sk_double_ceil2int(x)       (int)sk_double_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