@shopify/react-native-skia 2.4.6 → 2.4.14

package/android/cpp/jni/JniPlatformContext.cpp

@@ -207,7 +207,7 @@ void JniPlatformContext::notifyTaskReadyExternal() {
   jni::ThreadScope ts;
 
   static auto method =
-    javaPart_->getClass()->getMethod<void()>("notifyTaskReady");
+      javaPart_->getClass()->getMethod<void()>("notifyTaskReady");
   method(javaPart_.get());
 }
 

package/android/src/main/java/com/shopify/reactnative/skia/ViewScreenshotService.java

@@ -67,6 +67,16 @@ public class ViewScreenshotService {
         return paint;
     }
 
+    private static boolean isSvgView(View view) {
+        try {
+            String className = view.getClass().getName();
+            return className != null && className.startsWith("com.horcrux.svg");
+        } catch (Throwable t) {
+            Log.e("ViewScreenshotService", "Error checking if view is SVG", t);
+            return false;
+        }
+    }
+
     private static void renderViewToCanvas(Canvas canvas, View view, Paint paint, float parentOpacity) {
         float combinedOpacity = parentOpacity * view.getAlpha();
         canvas.save();
@@ -83,7 +93,7 @@ public class ViewScreenshotService {
             canvas.clipRect(clipLeft, clipTop, clipRight, clipBottom);
         }
 
-        if (view instanceof ViewGroup) {
+        if (view instanceof ViewGroup && !isSvgView(view)) {
             ViewGroup group = (ViewGroup) view;
             drawBackgroundIfPresent(canvas, view, combinedOpacity);
             drawChildren(canvas, group, paint, combinedOpacity);

package/apple/RNSkApplePlatformContext.h

@@ -73,6 +73,10 @@ public:
 
   sk_sp<SkFontMgr> createFontMgr() override;
 
+  std::vector<std::string> getSystemFontFamilies() override;
+
+  std::string resolveFontFamily(const std::string &familyName) override;
+
 private:
   ViewScreenshotService *_screenshotService;
 

package/apple/RNSkApplePlatformContext.mm

@@ -3,6 +3,7 @@
 #import <CoreMedia/CMSampleBuffer.h>
 #include <Metal/Metal.h>
 #import <React/RCTUtils.h>
+#include <set>
 #include <thread>
 #include <utility>
 
@@ -300,6 +301,74 @@ sk_sp<SkFontMgr> RNSkApplePlatformContext::createFontMgr() {
   return SkFontMgr_New_CoreText(nullptr);
 }
 
+std::vector<std::string> RNSkApplePlatformContext::getSystemFontFamilies() {
+  std::vector<std::string> families;
+
+  // System UI fonts (e.g., .AppleSystemUIFont) are not enumerated by Skia's
+  // font manager. We retrieve them via Core Text's CTFontUIFontType constants.
+  // This list covers common system font types as of iOS 17 / macOS 14.
+  // Apple may add new CTFontUIFontType values in future OS versions,
+  // so this list may need to be updated periodically.
+  CTFontUIFontType fontTypes[] = {
+      kCTFontUIFontUser,        kCTFontUIFontUserFixedPitch,
+      kCTFontUIFontSystem,      kCTFontUIFontEmphasizedSystem,
+      kCTFontUIFontSmallSystem, kCTFontUIFontSmallEmphasizedSystem,
+      kCTFontUIFontMiniSystem,  kCTFontUIFontMiniEmphasizedSystem,
+      kCTFontUIFontLabel,       kCTFontUIFontMessage,
+      kCTFontUIFontToolTip,
+  };
+
+  std::set<std::string> uniqueFamilies;
+
+  for (CTFontUIFontType fontType : fontTypes) {
+    CTFontRef font = CTFontCreateUIFontForLanguage(fontType, 12.0, nullptr);
+    if (font) {
+      CFStringRef familyName = CTFontCopyFamilyName(font);
+      if (familyName) {
+        const char *cstr =
+            CFStringGetCStringPtr(familyName, kCFStringEncodingUTF8);
+        if (cstr) {
+          uniqueFamilies.insert(std::string(cstr));
+        } else {
+          char buffer[256];
+          if (CFStringGetCString(familyName, buffer, sizeof(buffer),
+                                 kCFStringEncodingUTF8)) {
+            uniqueFamilies.insert(std::string(buffer));
+          }
+        }
+        CFRelease(familyName);
+      }
+      CFRelease(font);
+    }
+  }
+
+  families.assign(uniqueFamilies.begin(), uniqueFamilies.end());
+  return families;
+}
+
+std::string
+RNSkApplePlatformContext::resolveFontFamily(const std::string &familyName) {
+  // Handle special font family names like React Native does
+  // See: RCTFont.mm in React Native
+  if (familyName == "System" || familyName == "system" ||
+      familyName == "sans-serif") {
+    return ".AppleSystemUIFont";
+  }
+  if (familyName == "SystemCondensed" || familyName == "system-condensed") {
+    // Return system font - condensed trait is handled via font style
+    return ".AppleSystemUIFont";
+  }
+  // CSS generic font families
+  if (familyName == "serif") {
+    return "Times New Roman";
+  }
+  if (familyName == "monospace") {
+    return "Courier New";
+  }
+  // Return as-is if no mapping exists
+  return familyName;
+}
+
 void RNSkApplePlatformContext::runOnMainThread(std::function<void()> func) {
   dispatch_async(dispatch_get_main_queue(), ^{
     func();

package/apple/SkiaCVPixelBufferUtils.mm

@@ -30,12 +30,16 @@
 #include <TargetConditionals.h>
 #if TARGET_RT_BIG_ENDIAN
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*((char *)&fourcc), *(((char *)&fourcc) + 1),                 \
-                 *(((char *)&fourcc) + 2), *(((char *)&fourcc) + 3), 0}
+  (const char[]) {                                                             \
+    *((char *)&fourcc), *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 2),    \
+        *(((char *)&fourcc) + 3), 0                                            \
+  }
 #else
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),           \
-                 *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0}
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
 #endif
 
 // pragma MARK: TextureHolder

package/cpp/api/JsiSkFontMgr.h

@@ -27,21 +27,42 @@ public:
 
   JsiSkFontMgr(std::shared_ptr<RNSkPlatformContext> context,
                sk_sp<SkFontMgr> fontMgr)
-      : JsiSkWrappingSkPtrHostObject(std::move(context), fontMgr) {}
+      : JsiSkWrappingSkPtrHostObject(context, fontMgr),
+        _systemFontFamilies(context->getSystemFontFamilies()) {}
 
-  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+  JSI_HOST_FUNCTION(countFamilies) {
+    return static_cast<int>(getObject()->countFamilies() +
+                            _systemFontFamilies.size());
+  }
 
   JSI_HOST_FUNCTION(getFamilyName) {
     auto i = static_cast<int>(arguments[0].asNumber());
-    SkString name;
-    getObject()->getFamilyName(i, &name);
-    return jsi::String::createFromUtf8(runtime, name.c_str());
+    auto baseFamilyCount = getObject()->countFamilies();
+    if (i < baseFamilyCount) {
+      SkString name;
+      getObject()->getFamilyName(i, &name);
+      return jsi::String::createFromUtf8(runtime, name.c_str());
+    }
+    auto systemIndex = i - baseFamilyCount;
+    if (systemIndex < static_cast<int>(_systemFontFamilies.size())) {
+      return jsi::String::createFromUtf8(runtime,
+                                         _systemFontFamilies[systemIndex]);
+    }
+    throw jsi::JSError(
+        runtime,
+        "Font family index out of bounds: " + std::to_string(i) +
+            " (total families: " +
+            std::to_string(baseFamilyCount + _systemFontFamilies.size()) + ")");
   }
 
   JSI_HOST_FUNCTION(matchFamilyStyle) {
     auto name = arguments[0].asString(runtime).utf8(runtime);
+    // Resolve font family aliases (e.g., "System" -> ".AppleSystemUIFont" on
+    // iOS)
+    auto resolvedName = getContext()->resolveFontFamily(name);
     auto fontStyle = JsiSkFontStyle::fromValue(runtime, arguments[1]);
-    auto typeface = getObject()->matchFamilyStyle(name.c_str(), *fontStyle);
+    auto typeface =
+        getObject()->matchFamilyStyle(resolvedName.c_str(), *fontStyle);
     auto hostObjectInstance =
         std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
@@ -55,6 +76,9 @@ public:
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkFontMgr, countFamilies),
                        JSI_EXPORT_FUNC(JsiSkFontMgr, getFamilyName),
                        JSI_EXPORT_FUNC(JsiSkFontMgr, matchFamilyStyle))
+
+private:
+  std::vector<std::string> _systemFontFamilies;
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkImageFilterFactory.h

@@ -245,9 +245,11 @@ public:
   JSI_HOST_FUNCTION(MakeRuntimeShader) {
     auto rtb = JsiSkRuntimeShaderBuilder::fromValue(runtime, arguments[0]);
 
-    const char *childName = "";
+    std::string childNameStr = "";
+    const char *childName = childNameStr.c_str();
     if (hasOptionalArgument(arguments, count, 1)) {
-      childName = arguments[1].asString(runtime).utf8(runtime).c_str();
+      childNameStr = arguments[1].asString(runtime).utf8(runtime);
+      childName = childNameStr.c_str();
     }
 
     sk_sp<SkImageFilter> input = nullptr;

package/cpp/api/JsiSkPictureFactory.h

@@ -50,12 +50,15 @@ public:
       }
     }
 
-    // Get ArrayBuffer - try buffer property first (Uint8Array, etc.), then direct ArrayBuffer
-    jsi::ArrayBuffer buffer = obj.hasProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
-        ? obj.getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
-              .asObject(runtime)
-              .getArrayBuffer(runtime)
-        : obj.getArrayBuffer(runtime);
+    // Get ArrayBuffer - try buffer property first (Uint8Array, etc.), then
+    // direct ArrayBuffer
+    jsi::ArrayBuffer buffer =
+        obj.hasProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+            ? obj.getProperty(runtime,
+                              jsi::PropNameID::forAscii(runtime, "buffer"))
+                  .asObject(runtime)
+                  .getArrayBuffer(runtime)
+            : obj.getArrayBuffer(runtime);
 
     sk_sp<SkData> data =
         SkData::MakeWithCopy(buffer.data(runtime), buffer.size(runtime));

package/cpp/api/recorder/RNRecorder.h

@@ -78,8 +78,8 @@ private:
     for (const auto &child : group->children) {
       if (child->type == CommandType::Group) {
         auto *childGroup = static_cast<GroupCommand *>(child.get());
-        pending.push_back(
-            {childGroup, sanitizeZIndex(childGroup), static_cast<int>(pending.size())});
+        pending.push_back({childGroup, sanitizeZIndex(childGroup),
+                           static_cast<int>(pending.size())});
       } else {
         flushPendingGroups(ctx, pending);
         playCommand(ctx, child.get());
@@ -94,9 +94,7 @@ public:
   std::shared_ptr<RNSkPlatformContext> _context;
   Variables variables;
 
-  Recorder() {
-    commandStack.push_back(&commands);
-  }
+  Recorder() { commandStack.push_back(&commands); }
   ~Recorder() {
     if (!_context || commands.empty()) {
       return;
@@ -128,14 +126,11 @@ public:
       pushCommand(
           std::make_unique<PushImageShaderCmd>(runtime, props, variables));
     } else if (nodeType == "skColorShader") {
-      pushCommand(
-          std::make_unique<ColorShaderCmd>(runtime, props, variables));
+      pushCommand(std::make_unique<ColorShaderCmd>(runtime, props, variables));
     } else if (nodeType == "skTurbulence") {
-      pushCommand(
-          std::make_unique<TurbulenceCmd>(runtime, props, variables));
+      pushCommand(std::make_unique<TurbulenceCmd>(runtime, props, variables));
     } else if (nodeType == "skFractalNoise") {
-      pushCommand(
-          std::make_unique<FractalNoiseCmd>(runtime, props, variables));
+      pushCommand(std::make_unique<FractalNoiseCmd>(runtime, props, variables));
     } else if (nodeType == "skLinearGradient") {
       pushCommand(
           std::make_unique<LinearGradientCmd>(runtime, props, variables));
@@ -146,12 +141,11 @@ public:
       pushCommand(
           std::make_unique<SweepGradientCmd>(runtime, props, variables));
     } else if (nodeType == "skTwoPointConicalGradient") {
-      pushCommand(std::make_unique<TwoPointConicalGradientCmd>(
-          runtime, props, variables));
+      pushCommand(std::make_unique<TwoPointConicalGradientCmd>(runtime, props,
+                                                               variables));
       // TODO: should receive skBlendShader here
     } else if (nodeType == "skBlend") {
-      pushCommand(
-          std::make_unique<BlendShaderCmd>(runtime, props, variables));
+      pushCommand(std::make_unique<BlendShaderCmd>(runtime, props, variables));
     }
   }
 
@@ -216,41 +210,36 @@ public:
       pushCommand(
           std::make_unique<BlurImageFilterCmd>(runtime, props, variables));
     } else if (nodeType == "skDropShadowImageFilter") {
-      pushCommand(std::make_unique<DropShadowImageFilterCmd>(
-          runtime, props, variables));
+      pushCommand(std::make_unique<DropShadowImageFilterCmd>(runtime, props,
+                                                             variables));
     } else if (nodeType == "skMorphologyImageFilter") {
-      pushCommand(std::make_unique<MorphologyImageFilterCmd>(
-          runtime, props, variables));
+      pushCommand(std::make_unique<MorphologyImageFilterCmd>(runtime, props,
+                                                             variables));
     } else if (nodeType == "skBlendImageFilter") {
       pushCommand(
           std::make_unique<BlendImageFilterCmd>(runtime, props, variables));
     } else if (nodeType == "skRuntimeShaderImageFilter") {
-      pushCommand(std::make_unique<RuntimeShaderImageFilterCmd>(
-          runtime, props, variables));
+      pushCommand(std::make_unique<RuntimeShaderImageFilterCmd>(runtime, props,
+                                                                variables));
     } else if (nodeType == "skImageFilter") {
-      pushCommand(
-          std::make_unique<ImageFilterCmd>(runtime, props, variables));
+      pushCommand(std::make_unique<ImageFilterCmd>(runtime, props, variables));
     }
   }
 
   void composePathEffect() {
-    pushCommand(
-        std::make_unique<Command>(CommandType::ComposePathEffect));
+    pushCommand(std::make_unique<Command>(CommandType::ComposePathEffect));
   }
 
   void composeImageFilter() {
-    pushCommand(
-        std::make_unique<Command>(CommandType::ComposeImageFilter));
+    pushCommand(std::make_unique<Command>(CommandType::ComposeImageFilter));
   }
 
   void composeColorFilter() {
-    pushCommand(
-        std::make_unique<Command>(CommandType::ComposeColorFilter));
+    pushCommand(std::make_unique<Command>(CommandType::ComposeColorFilter));
   }
 
   void pushBlurMaskFilter(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<BlurMaskFilterCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<BlurMaskFilterCmd>(runtime, props, variables));
   }
 
   void saveCTM(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -278,8 +267,7 @@ public:
   }
 
   void drawTextPath(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<TextPathCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<TextPathCmd>(runtime, props, variables));
   }
 
   void drawText(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -296,8 +284,7 @@ public:
 
   void drawBox(jsi::Runtime &runtime, const jsi::Object &props,
                const jsi::Array &shadows) {
-    pushCommand(
-        std::make_unique<BoxCmd>(runtime, props, shadows, variables));
+    pushCommand(std::make_unique<BoxCmd>(runtime, props, shadows, variables));
   }
 
   void drawImage(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -322,18 +309,15 @@ public:
   }
 
   void drawVertices(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<VerticesCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<VerticesCmd>(runtime, props, variables));
   }
 
   void drawDiffRect(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<DiffRectCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<DiffRectCmd>(runtime, props, variables));
   }
 
   void drawTextBlob(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<TextBlobCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<TextBlobCmd>(runtime, props, variables));
   }
 
   void drawGlyphs(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -346,13 +330,11 @@ public:
   }
 
   void drawImageSVG(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<ImageSVGCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<ImageSVGCmd>(runtime, props, variables));
   }
 
   void drawParagraph(jsi::Runtime &runtime, const jsi::Object &props) {
-    pushCommand(
-        std::make_unique<ParagraphCmd>(runtime, props, variables));
+    pushCommand(std::make_unique<ParagraphCmd>(runtime, props, variables));
   }
 
   void drawAtlas(jsi::Runtime &runtime, const jsi::Object &props) {
@@ -365,8 +347,7 @@ public:
   }
 
   void materializePaint() {
-    pushCommand(
-        std::make_unique<Command>(CommandType::MaterializePaint));
+    pushCommand(std::make_unique<Command>(CommandType::MaterializePaint));
   }
 
   void restorePaintDeclaration() {
@@ -379,11 +360,11 @@ public:
   }
 
   void saveBackdropFilter() {
-    pushCommand(
-        std::make_unique<Command>(CommandType::SaveBackdropFilter));
+    pushCommand(std::make_unique<Command>(CommandType::SaveBackdropFilter));
   }
 
-  void saveGroup(jsi::Runtime &runtime, const jsi::Value *propsValue = nullptr) {
+  void saveGroup(jsi::Runtime &runtime,
+                 const jsi::Value *propsValue = nullptr) {
     auto group = std::make_unique<GroupCommand>();
     if (propsValue != nullptr && propsValue->isObject()) {
       auto object = propsValue->asObject(runtime);
@@ -400,7 +381,6 @@ public:
     }
   }
 
-
   void play(DrawingCtx *ctx) {
     for (const auto &cmd : commands) {
       playCommand(ctx, cmd.get());
@@ -497,8 +477,7 @@ inline void Recorder::playCommand(DrawingCtx *ctx, Command *cmd) {
       auto *offsetCmd = static_cast<OffsetImageFilterCmd *>(cmd);
       offsetCmd->pushImageFilter(ctx);
     } else if (nodeType == "skDisplacementMapImageFilter") {
-      auto *displacementCmd =
-          static_cast<DisplacementMapImageFilterCmd *>(cmd);
+      auto *displacementCmd = static_cast<DisplacementMapImageFilterCmd *>(cmd);
       displacementCmd->pushImageFilter(ctx);
     } else if (nodeType == "skBlurImageFilter") {
       auto *blurCmd = static_cast<BlurImageFilterCmd *>(cmd);
@@ -513,8 +492,7 @@ inline void Recorder::playCommand(DrawingCtx *ctx, Command *cmd) {
       auto *blendCmd = static_cast<BlendImageFilterCmd *>(cmd);
       blendCmd->pushImageFilter(ctx);
     } else if (nodeType == "skRuntimeShaderImageFilter") {
-      auto *runtimeShaderCmd =
-          static_cast<RuntimeShaderImageFilterCmd *>(cmd);
+      auto *runtimeShaderCmd = static_cast<RuntimeShaderImageFilterCmd *>(cmd);
       runtimeShaderCmd->pushImageFilter(ctx);
     } else if (nodeType == "skImageFilter") {
       auto *imageFilterCmd = static_cast<ImageFilterCmd *>(cmd);

package/cpp/rnskia/RNSkPictureView.h

@@ -60,14 +60,16 @@ public:
 
 private:
   bool performDraw(std::shared_ptr<RNSkCanvasProvider> canvasProvider) {
-    return canvasProvider->renderToCanvas([=, this](SkCanvas *canvas) {
-      // Make sure to scale correctly
-      auto pd = _platformContext->getPixelDensity();
+    // Capture picture pointer to ensure thread safety - _picture can be
+    // modified from the JS thread while we're drawing on the render thread
+    sk_sp<SkPicture> picture = _picture;
+    auto pd = _platformContext->getPixelDensity();
+    return canvasProvider->renderToCanvas([=](SkCanvas *canvas) {
       canvas->clear(SK_ColorTRANSPARENT);
       canvas->save();
       canvas->scale(pd, pd);
-      if (_picture != nullptr) {
-        canvas->drawPicture(_picture);
+      if (picture != nullptr) {
+        canvas->drawPicture(picture);
       }
       canvas->restore();
     });

package/cpp/rnskia/RNSkPlatformContext.h

@@ -8,6 +8,7 @@
 #include <thread>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "RNSkVideo.h"
 #include "RNWindowContext.h"
@@ -145,6 +146,21 @@ public:
    */
   virtual sk_sp<SkFontMgr> createFontMgr() = 0;
 
+  /**
+   * Return platform-specific system font family names that aren't
+   * enumerated by the standard font manager (e.g., .AppleSystemUIFont on iOS)
+   */
+  virtual std::vector<std::string> getSystemFontFamilies() { return {}; }
+
+  /**
+   * Resolve font family aliases to actual font family names.
+   * For example, "System" on iOS resolves to ".AppleSystemUIFont".
+   * Returns the input unchanged if no mapping exists.
+   */
+  virtual std::string resolveFontFamily(const std::string &familyName) {
+    return familyName;
+  }
+
   /**
    * Creates an skImage containing the screenshot of a native view and its
    * children.

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

@@ -76,7 +76,8 @@ public:
      *  The SkPngChunkReader handles unknown chunks in PNGs.
      *  See SkCodec.h for more details.
      */
-    static std::unique_ptr<SkAndroidCodec> MakeFromData(sk_sp<SkData>, SkPngChunkReader* = nullptr);
+    static std::unique_ptr<SkAndroidCodec> MakeFromData(sk_sp<const SkData>,
+                                                        SkPngChunkReader* = nullptr);
 
     virtual ~SkAndroidCodec();
 
@@ -285,7 +286,7 @@ public:
                            std::unique_ptr<SkStream>* outGainmapImageStream);
 
 protected:
-    SkAndroidCodec(SkCodec*);
+    explicit SkAndroidCodec(SkCodec*);
 
     virtual SkISize onGetSampledDimensions(int sampleSize) const = 0;
 

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

@@ -33,7 +33,7 @@ SK_API bool IsAvif(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
@@ -65,7 +65,7 @@ SK_API bool IsAvif(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 

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

@@ -31,7 +31,7 @@ SK_API bool IsBmp(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 

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

@@ -212,11 +212,11 @@ public:
      *      If the PNG does not contain unknown chunks, the SkPngChunkReader
      *      will not be used or modified.
      */
-    static std::unique_ptr<SkCodec> MakeFromData(sk_sp<SkData>,
+    static std::unique_ptr<SkCodec> MakeFromData(sk_sp<const SkData>,
                                                  SkSpan<const SkCodecs::Decoder> decoders,
                                                  SkPngChunkReader* = nullptr);
     // deprecated
-    static std::unique_ptr<SkCodec> MakeFromData(sk_sp<SkData>, SkPngChunkReader* = nullptr);
+    static std::unique_ptr<SkCodec> MakeFromData(sk_sp<const SkData>, SkPngChunkReader* = nullptr);
 
     virtual ~SkCodec();
 
@@ -849,12 +849,6 @@ protected:
             std::unique_ptr<SkStream>,
             SkEncodedOrigin = kTopLeft_SkEncodedOrigin);
 
-    void setSrcXformFormat(XformFormat pixelFormat);
-
-    XformFormat getSrcXformFormat() const {
-        return fSrcXformFormat;
-    }
-
     virtual bool onGetGainmapCodec(SkGainmapInfo*, std::unique_ptr<SkCodec>*) { return false; }
     virtual bool onGetGainmapInfo(SkGainmapInfo*) { return false; }
 

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

@@ -43,6 +43,23 @@ static inline SkMatrix SkEncodedOriginToMatrix(SkEncodedOrigin origin, int w, in
     SK_ABORT("Unexpected origin");
 }
 
+/**
+ * Return a matrix equal to SkEncodedOriginToMatrix(origin, w, h).invert().
+ */
+static inline SkMatrix SkEncodedOriginToMatrixInverse(SkEncodedOrigin origin, int w, int h) {
+    switch (origin) {
+        case     kTopLeft_SkEncodedOrigin: return SkMatrix::I();
+        case    kTopRight_SkEncodedOrigin: return SkMatrix::MakeAll(-1,  0, w,  0,  1, 0, 0, 0, 1);
+        case kBottomRight_SkEncodedOrigin: return SkMatrix::MakeAll(-1,  0, w,  0, -1, h, 0, 0, 1);
+        case  kBottomLeft_SkEncodedOrigin: return SkMatrix::MakeAll( 1,  0, 0,  0, -1, h, 0, 0, 1);
+        case     kLeftTop_SkEncodedOrigin: return SkMatrix::MakeAll( 0,  1, 0,  1,  0, 0, 0, 0, 1);
+        case    kRightTop_SkEncodedOrigin: return SkMatrix::MakeAll( 0,  1, 0, -1,  0, w, 0, 0, 1);
+        case kRightBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0, -1, h, -1,  0, w, 0, 0, 1);
+        case  kLeftBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0, -1, h,  1,  0, 0, 0, 0, 1);
+    }
+    SK_ABORT("Unexpected origin");
+}
+
 /**
  * Return true if the encoded origin includes a 90 degree rotation, in which case the width
  * and height of the source data are swapped relative to a correctly oriented destination.

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

@@ -31,7 +31,7 @@ SK_API bool IsGif(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 

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

@@ -31,7 +31,7 @@ SK_API bool IsIco(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 

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

@@ -31,10 +31,17 @@ SK_API bool IsJpeg(const void*, size_t);
 SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
-SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<const SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
+// TODO: remove after client migration
+inline std::unique_ptr<SkCodec> Decode(sk_sp<SkData> data,
+                                       SkCodec::Result* result,
+                                       SkCodecs::DecodeContext ctx = nullptr) {
+    return Decode(sk_sp<const SkData>(static_cast<const SkData*>(data.release())), result, ctx);
+}
+
 inline constexpr SkCodecs::Decoder Decoder() {
     return { "jpeg", IsJpeg, Decode };
 }