@shopify/react-native-skia 0.1.192 → 0.1.194

package/cpp/skia/include/codec/SkCodec.h

@@ -8,10 +8,7 @@
 #ifndef SkCodec_DEFINED
 #define SkCodec_DEFINED
 
-#include "include/codec/SkCodecAnimation.h"
 #include "include/codec/SkEncodedOrigin.h"
-#include "include/core/SkAlphaType.h"
-#include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkPixmap.h"
 #include "include/core/SkRect.h"
@@ -20,21 +17,30 @@
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAPixmaps.h"
 #include "include/private/SkEncodedInfo.h"
-#include "include/private/SkNoncopyable.h"
+#include "include/private/base/SkNoncopyable.h"
 #include "modules/skcms/skcms.h"
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <tuple>
 #include <vector>
 
-class SkAndroidCodec;
 class SkData;
 class SkFrameHolder;
 class SkImage;
 class SkPngChunkReader;
 class SkSampler;
 class SkStream;
+struct SkGainmapInfo;
+enum SkAlphaType : int;
+enum class SkEncodedImageFormat;
+
+namespace SkCodecAnimation {
+enum class Blend;
+enum class DisposalMethod;
+}
+
 
 namespace DM {
 class CodecSrc;
@@ -767,6 +773,8 @@ protected:
         return fSrcXformFormat;
     }
 
+    virtual bool onGetGainmapInfo(SkGainmapInfo*, std::unique_ptr<SkStream>*) { return false; }
+
     virtual SkISize onGetScaledDimensions(float /*desiredScale*/) const {
         // By default, scaling is not supported.
         return this->dimensions();
@@ -887,8 +895,8 @@ private:
     const SkEncodedInfo                fEncodedInfo;
     XformFormat                        fSrcXformFormat;
     std::unique_ptr<SkStream>          fStream;
-    bool                               fNeedsRewind;
-    const SkEncodedOrigin              fOrigin;
+    bool fNeedsRewind = false;
+    const SkEncodedOrigin fOrigin;
 
     SkImageInfo                        fDstInfo;
     Options                            fOptions;
@@ -904,13 +912,13 @@ private:
     skcms_AlphaFormat                  fDstXformAlphaFormat;
 
     // Only meaningful during scanline decodes.
-    int                                fCurrScanline;
+    int fCurrScanline = -1;
 
-    bool                               fStartedIncrementalDecode;
+    bool fStartedIncrementalDecode = false;
 
     // Allows SkAndroidCodec to call handleFrameIndex (potentially decoding a prior frame and
-    // clearing to transparent) without SkCodec calling it, too.
-    bool                               fAndroidCodecHandlesFrameIndex;
+    // clearing to transparent) without SkCodec itself calling it, too.
+    bool fUsingCallbackForHandleFrameIndex = false;
 
     bool initializeColorXform(const SkImageInfo& dstInfo, SkEncodedInfo::Alpha, bool srcIsOpaque);
 
@@ -934,17 +942,23 @@ private:
         return nullptr;
     }
 
+    // Callback for decoding a prior frame. The `Options::fFrameIndex` is ignored,
+    // being replaced by frameIndex. This allows opts to actually be a subclass of
+    // SkCodec::Options which SkCodec itself does not know how to copy or modify,
+    // but just passes through to the caller (where it can be reinterpret_cast'd).
+    using GetPixelsCallback = std::function<Result(const SkImageInfo&, void* pixels,
+                                                   size_t rowBytes, const Options& opts,
+                                                   int frameIndex)>;
+
     /**
      *  Check for a valid Options.fFrameIndex, and decode prior frames if necessary.
      *
-     *  If androidCodec is not null, that means this SkCodec is owned by an SkAndroidCodec. In that
-     *  case, the Options will be treated as an AndroidOptions, and SkAndroidCodec will be used to
-     *  decode a prior frame, if a prior frame is needed. When such an owned SkCodec calls
-     *  handleFrameIndex, it will immediately return kSuccess, since SkAndroidCodec already handled
-     *  it.
+     * If GetPixelsCallback is not null, it will be used to decode a prior frame instead
+     * of using this SkCodec directly. It may also be used recursively, if that in turn
+     * depends on a prior frame. This is used by SkAndroidCodec.
      */
     Result handleFrameIndex(const SkImageInfo&, void* pixels, size_t rowBytes, const Options&,
-            SkAndroidCodec* androidCodec = nullptr);
+                            GetPixelsCallback = nullptr);
 
     // Methods for scanline decoding.
     virtual Result onStartScanlineDecode(const SkImageInfo& /*dstInfo*/,

package/cpp/skia/include/codec/SkEncodedImageFormat.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncodedImageFormat_DEFINED
+#define SkEncodedImageFormat_DEFINED
+
+#include <stdint.h>
+
+/**
+ *  Enum describing format of encoded data.
+ */
+enum class SkEncodedImageFormat {
+#ifdef SK_BUILD_FOR_GOOGLE3
+    kUnknown,
+#endif
+    kBMP,
+    kGIF,
+    kICO,
+    kJPEG,
+    kPNG,
+    kWBMP,
+    kWEBP,
+    kPKM,
+    kKTX,
+    kASTC,
+    kDNG,
+    kHEIF,
+    kAVIF,
+    kJPEGXL,
+};
+
+#endif  // SkEncodedImageFormat_DEFINED

package/cpp/skia/include/codec/SkPixmapUtils.h

@@ -0,0 +1,31 @@
+/*
+ * 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 SkPixmapUtils_DEFINED
+#define SkPixmapUtils_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkImageInfo.h"
+#include "include/private/base/SkAPI.h"
+
+class SkPixmap;
+
+namespace SkPixmapUtils {
+/**
+ *  Copy the pixels in src into dst, applying the orientation transformations specified
+ *  by origin. If the inputs are invalid, this returns false and no copy is made.
+ */
+SK_API bool Orient(const SkPixmap& dst, const SkPixmap& src, SkEncodedOrigin origin);
+
+/**
+ *  Return a copy of the provided ImageInfo with the width and height swapped.
+ */
+SK_API SkImageInfo SwapWidthHeight(const SkImageInfo& info);
+
+}  // namespace SkPixmapUtils
+
+#endif // SkPixmapUtils_DEFINED

package/cpp/skia/include/config/SkUserConfig.h

@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -6,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-
 #ifndef SkUserConfig_DEFINED
 #define SkUserConfig_DEFINED
 
@@ -16,9 +14,9 @@
 
     Below are optional defines that add, subtract, or change default behavior
     in Skia. Your port can locally edit this file to enable/disable flags as
-    you choose, or these can be delared on your command line (i.e. -Dfoo).
+    you choose, or these can be declared on your command line (i.e. -Dfoo).
 
-    By default, this include file will always default to having all of the flags
+    By default, this #include file will always default to having all the flags
     commented out, so including it will have no effect.
 */
 
@@ -32,58 +30,92 @@
     By default, these mutually exclusive flags are defined in SkTypes.h,
     based on the presence or absence of NDEBUG, but that decision can be changed
     here.
- */
+*/
 //#define SK_DEBUG
 //#define SK_RELEASE
 
 /*  To write debug messages to a console, skia will call SkDebugf(...) following
     printf conventions (e.g. const char* format, ...). If you want to redirect
     this to something other than printf, define yours here
- */
+*/
 //#define SkDebugf(...)  MyFunction(__VA_ARGS__)
 
-/*
- *  To specify a different default font cache limit, define this. If this is
- *  undefined, skia will use a built-in value.
- */
+/* Skia has both debug and release asserts. When an assert fails SK_ABORT will
+   be used to report an abort message. SK_ABORT is expected not to return. Skia
+   provides a default implementation which will print the message with SkDebugf
+   and then call sk_abort_no_print.
+*/
+//#define SK_ABORT(message, ...)
+
+/* To specify a different default font strike cache memory limit, define this. If this is
+   undefined, skia will use a built-in value.
+*/
 //#define SK_DEFAULT_FONT_CACHE_LIMIT   (1024 * 1024)
 
-/*
- *  To specify the default size of the image cache, undefine this and set it to
- *  the desired value (in bytes). SkGraphics.h as a runtime API to set this
- *  value as well. If this is undefined, a built-in value will be used.
- */
+/* To specify a different default font strike cache count limit, define this. If this is
+   undefined, skia will use a built-in value.
+*/
+// #define SK_DEFAULT_FONT_CACHE_COUNT_LIMIT   2048
+
+/* To specify the default size of the image cache, undefine this and set it to
+   the desired value (in bytes). SkGraphics.h as a runtime API to set this
+   value as well. If this is undefined, a built-in value will be used.
+*/
 //#define SK_DEFAULT_IMAGE_CACHE_LIMIT (1024 * 1024)
 
 /*  Define this to set the upper limit for text to support LCD. Values that
     are very large increase the cost in the font cache and draw slower, without
     improving readability. If this is undefined, Skia will use its default
     value (e.g. 48)
- */
+*/
 //#define SK_MAX_SIZE_FOR_LCDTEXT     48
 
 /*  Change the kN32_SkColorType ordering to BGRA to work in X windows.
- */
+*/
 //#define SK_R32_SHIFT    16
 
-
-/* Determines whether to build code that supports the GPU backend. Some classes
+/* Determines whether to build code that supports the Ganesh GPU backend. Some classes
    that are not GPU-specific, such as SkShader subclasses, have optional code
-   that is used allows them to interact with the GPU backend. If you'd like to
-   omit this code set SK_SUPPORT_GPU to 0. This also allows you to omit the gpu
-   directories from your include search path when you're not building the GPU
-   backend. Defaults to 1 (build the GPU code).
- */
-//#define SK_SUPPORT_GPU 1
+   that is used allows them to interact with this GPU backend. If you'd like to
+   include this code, include -DSK_GANESH in your cflags or uncomment below.
+   Defaults to not set (No Ganesh GPU backend).
+   This define affects the ABI of Skia, so make sure it matches the client which uses
+   the compiled version of Skia.
+*/
+//#define SK_GANESH
 
 /* Skia makes use of histogram logging macros to trace the frequency of
- * events. By default, Skia provides no-op versions of these macros.
- * Skia consumers can provide their own definitions of these macros to
- * integrate with their histogram collection backend.
- */
+   events. By default, Skia provides no-op versions of these macros.
+   Skia consumers can provide their own definitions of these macros to
+   integrate with their histogram collection backend.
+*/
 //#define SK_HISTOGRAM_BOOLEAN(name, sample)
 //#define SK_HISTOGRAM_ENUMERATION(name, sample, enum_size)
 //#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
 
+/* Skia tries to make use of some non-standard C++ language extensions.
+   By default, Skia provides msvc and clang/gcc versions of these macros.
+   Skia consumers can provide their own definitions of these macros to
+   integrate with their own compilers and build system.
+*/
+//#define SK_UNUSED [[maybe_unused]]
+//#define SK_WARN_UNUSED_RESULT [[nodiscard]]
+//#define SK_ALWAYS_INLINE inline __attribute__((always_inline))
+//#define SK_NEVER_INLINE __attribute__((noinline))
+//#define SK_PRINTF_LIKE(A, B) __attribute__((format(printf, (A), (B))))
+//#define SK_NO_SANITIZE(A) __attribute__((no_sanitize(A)))
+//#define SK_TRIVIAL_ABI [[clang::trivial_abi]]
+
+/*
+ * If compiling Skia as a DLL, public APIs should be exported. Skia will set
+ * SK_API to something sensible for Clang and MSVC, but if clients need to
+ * customize it for their build system or compiler, they may.
+ * If a client needs to use SK_API (e.g. overriding SK_ABORT), then they
+ * *must* define their own, the default will not be defined prior to loading
+ * this file.
+ */
+//#define SK_API __declspec(dllexport)
+
+
 #endif

package/cpp/skia/include/core/SkBitmap.h

@@ -8,24 +8,32 @@
 #ifndef SkBitmap_DEFINED
 #define SkBitmap_DEFINED
 
+#include "include/core/SkAlphaType.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkImageInfo.h"
-#include "include/core/SkMatrix.h"
 #include "include/core/SkPixmap.h"
 #include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkTileMode.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkDebug.h"
+
+#include <cstddef>
+#include <cstdint>
 
-class SkBitmap;
 class SkColorSpace;
-struct SkMask;
+class SkImage;
+class SkMatrix;
 class SkMipmap;
-struct SkIRect;
-struct SkRect;
 class SkPaint;
 class SkPixelRef;
 class SkShader;
+enum SkColorType : int;
+enum class SkTileMode;
+struct SkMask;
 
 /** \class SkBitmap
     SkBitmap describes a two-dimensional raster pixel array. SkBitmap is built on
@@ -766,11 +774,10 @@ public:
         treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.
 
         @param c            unpremultiplied color
-        @param colorSpace   SkColorSpace of c
 
         example: https://fiddle.skia.org/c/@Bitmap_eraseColor
     */
-    void eraseColor(SkColor4f c, SkColorSpace* colorSpace = nullptr) const;
+    void eraseColor(SkColor4f) const;
 
     /** Replaces pixel values with c, interpreted as being in the sRGB SkColorSpace.
         All pixels contained by bounds() are affected. If the colorType() is
@@ -810,11 +817,9 @@ public:
 
         @param c            unpremultiplied color
         @param area         rectangle to fill
-        @param colorSpace   SkColorSpace of c
 
         example: https://fiddle.skia.org/c/@Bitmap_erase
     */
-    void erase(SkColor4f c, SkColorSpace* colorSpace, const SkIRect& area) const;
     void erase(SkColor4f c, const SkIRect& area) const;
 
     /** Replaces pixel values inside area with c. interpreted as being in the sRGB
@@ -1168,23 +1173,18 @@ public:
         example: https://fiddle.skia.org/c/@Bitmap_peekPixels
     */
     bool peekPixels(SkPixmap* pixmap) const;
-    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions&,
-                               const SkMatrix* = nullptr) const;
 
+    /**
+     *  Make a shader with the specified tiling, matrix and sampling.
+     */
+    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions&,
+                               const SkMatrix* localMatrix = nullptr) const;
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions& sampling,
-                               const SkMatrix& localMatrix) const {
-        return this->makeShader(tmx, tmy, sampling, &localMatrix);
-    }
-
-    sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling,
-                               const SkMatrix* localMatrix = nullptr) const {
-        return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, localMatrix);
-    }
-
+                               const SkMatrix& lm) const;
+    /** Defaults to clamp in both X and Y. */
+    sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const;
     sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling,
-                               const SkMatrix& localMatrix) const {
-        return this->makeShader(sampling, &localMatrix);
-    }
+                               const SkMatrix* lm = nullptr) const;
 
     /**
      *  Returns a new image from the bitmap. If the bitmap is marked immutable, this will

package/cpp/skia/include/core/SkBlurTypes.h

@@ -8,8 +8,6 @@
 #ifndef SkBlurTypes_DEFINED
 #define SkBlurTypes_DEFINED
 
-#include "include/core/SkTypes.h"
-
 enum SkBlurStyle : int {
     kNormal_SkBlurStyle,  //!< fuzzy inside and outside
     kSolid_SkBlurStyle,   //!< solid inside, fuzzy outside

package/cpp/skia/include/core/SkCanvas.h

@@ -12,6 +12,7 @@
 #include "include/core/SkClipOp.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkFontTypes.h"
+#include "include/core/SkImageFilter.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkM44.h"
 #include "include/core/SkMatrix.h"
@@ -26,13 +27,13 @@
 #include "include/core/SkString.h"
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkDeque.h"
-#include "include/private/SkMacros.h"
+#include "include/private/base/SkCPUTypes.h"
+#include "include/private/base/SkDeque.h"
 
+#include <cstdint>
 #include <cstring>
 #include <memory>
 #include <optional>
-#include <vector>
 
 #ifndef SK_SUPPORT_LEGACY_GETTOTALMATRIX
 #define SK_SUPPORT_LEGACY_GETTOTALMATRIX
@@ -44,34 +45,39 @@ class GlyphRunList;
 }
 
 class AutoLayerForImageFilter;
-class GrBackendRenderTarget;
 class GrRecordingContext;
+
 class SkBaseDevice;
 class SkBitmap;
+class SkBlender;
 class SkData;
 class SkDrawable;
-struct SkDrawShadowRec;
 class SkFont;
 class SkImage;
-class SkImageFilter;
+class SkMesh;
 class SkPaintFilterCanvas;
 class SkPath;
 class SkPicture;
 class SkPixmap;
-class SkRegion;
 class SkRRect;
-struct SkRSXform;
-class SkMesh;
+class SkRegion;
+class SkShader;
 class SkSpecialImage;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 class SkVertices;
+struct SkDrawShadowRec;
+struct SkRSXform;
 
 namespace skgpu::graphite { class Recorder; }
 namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
 
+#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_GANESH)
+class GrBackendRenderTarget;
+#endif
+
 // TODO:
 // This is not ideal but Chrome is depending on a forward decl of GrSlug here.
 // It should be removed once Chrome has migrated to sktext::gpu::Slug.
@@ -650,7 +656,7 @@ public:
         SkRect bounds suggests but does not define layer size. To clip drawing to
         a specific rectangle, use clipRect().
 
-        alpha of zero is fully transparent, 255 is fully opaque.
+        alpha of zero is fully transparent, 1.0f is fully opaque.
 
         Call restoreToCount() with returned value to restore this and subsequent saves.
 
@@ -660,7 +666,11 @@ public:
 
         example: https://fiddle.skia.org/c/@Canvas_saveLayerAlpha
     */
-    int saveLayerAlpha(const SkRect* bounds, U8CPU alpha);
+    int saveLayerAlphaf(const SkRect* bounds, float alpha);
+    // Helper that accepts an int between 0 and 255, and divides it by 255.0
+    int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) {
+        return this->saveLayerAlphaf(bounds, alpha * (1.0f / 255));
+    }
 
     /** \enum SkCanvas::SaveLayerFlagsSet
         SaveLayerFlags provides options that may be used in any combination in SaveLayerRec,
@@ -2173,7 +2183,7 @@ public:
 
     ///////////////////////////////////////////////////////////////////////////
 
-#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && SK_SUPPORT_GPU
+#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_GANESH)
     // These methods exist to support WebView in Android Framework.
     SkIRect topLayerBounds() const;
     GrBackendRenderTarget topLayerBackendRenderTarget() const;
@@ -2290,7 +2300,7 @@ protected:
 
     virtual void onDiscard();
 
-#if (SK_SUPPORT_GPU || defined(SK_GRAPHITE_ENABLED))
+#if (defined(SK_GANESH) || defined(SK_GRAPHITE))
     /** Experimental
      */
     virtual sk_sp<sktext::gpu::Slug> onConvertGlyphRunListToSlug(
@@ -2352,6 +2362,13 @@ private:
 
     // Encapsulate state needed to restore from saveBehind()
     struct BackImage {
+        // Out of line to avoid including SkSpecialImage.h
+        BackImage(sk_sp<SkSpecialImage>, SkIPoint);
+        BackImage(const BackImage&);
+        BackImage(BackImage&&);
+        BackImage& operator=(const BackImage&);
+        ~BackImage();
+
         sk_sp<SkSpecialImage> fImage;
         SkIPoint              fLoc;
     };
@@ -2406,7 +2423,7 @@ private:
         fSurfaceBase = sb;
     }
     friend class SkSurface_Base;
-    friend class SkSurface_Gpu;
+    friend class SkSurface_Ganesh;
 
     SkIRect fClipRestrictionRect = SkIRect::MakeEmpty();
     int fClipRestrictionSaveCount = -1;
@@ -2440,7 +2457,7 @@ private:
     SkCanvas& operator=(SkCanvas&&) = delete;
     SkCanvas& operator=(const SkCanvas&) = delete;
 
-#if (SK_SUPPORT_GPU || defined(SK_GRAPHITE_ENABLED))
+#if (defined(SK_GANESH) || defined(SK_GRAPHITE))
     friend class sktext::gpu::Slug;
     /** Experimental
      * Convert a SkTextBlob to a sktext::gpu::Slug using the current canvas state.

package/cpp/skia/include/core/SkCapabilities.h

@@ -15,7 +15,7 @@
 namespace SkSL { struct ShaderCaps; }
 #endif
 
-#if defined(SK_GRAPHITE_ENABLED)
+#if defined(SK_GRAPHITE)
 namespace skgpu::graphite { class Caps; }
 #endif
 
@@ -28,7 +28,7 @@ public:
 #endif
 
 protected:
-#if defined(SK_GRAPHITE_ENABLED)
+#if defined(SK_GRAPHITE)
     friend class skgpu::graphite::Caps; // for ctor
 #endif
 

package/cpp/skia/include/core/SkColor.h

@@ -11,8 +11,10 @@
 #include "include/core/SkAlphaType.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkCPUTypes.h"
 
 #include <array>
+#include <cstdint>
 
 /** \file SkColor.h
 

package/cpp/skia/include/core/SkColorPriv.h

@@ -9,9 +9,11 @@
 #define SkColorPriv_DEFINED
 
 #include "include/core/SkColor.h"
-#include "include/core/SkMath.h"
-#include "include/private/SkTPin.h"
-#include "include/private/SkTo.h"
+#include "include/private/base/SkMath.h"
+#include "include/private/base/SkTPin.h"
+#include "include/private/base/SkTo.h"
+
+#include <algorithm>
 
 /** Turn 0..255 into 0..256 by adding 1 at the half-way point. Used to turn a
     byte into a scale value, so that we can say scale * value >> 8 instead of
@@ -146,7 +148,20 @@ static SK_ALWAYS_INLINE uint32_t SkAlphaMulQ(uint32_t c, unsigned scale) {
 }
 
 static inline SkPMColor SkPMSrcOver(SkPMColor src, SkPMColor dst) {
-    return src + SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src)));
+    uint32_t scale = SkAlpha255To256(255 - SkGetPackedA32(src));
+
+    uint32_t mask = 0xFF00FF;
+    uint32_t rb = (((dst & mask) * scale) >> 8) & mask;
+    uint32_t ag = (((dst >> 8) & mask) * scale) & ~mask;
+
+    rb += (src &  mask);
+    ag += (src & ~mask);
+
+    // Color channels (but not alpha) can overflow, so we have to saturate to 0xFF in each lane.
+    return std::min(rb & 0x000001FF, 0x000000FFU) |
+           std::min(ag & 0x0001FF00, 0x0000FF00U) |
+           std::min(rb & 0x01FF0000, 0x00FF0000U) |
+                   (ag & 0xFF000000);
 }
 
 #endif