@shopify/react-native-skia 0.1.197 → 0.1.200

package/android/CMakeLists.txt

@@ -47,21 +47,21 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/RNSkOpenGLCanvasProvider.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia-android/SkiaOpenGLRenderer.cpp"
 
-        "${PROJECT_SOURCE_DIR}/cpp/jsi/JsiHostObject.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/jsi/JsiValue.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/jsi/RuntimeLifecycleMonitor.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/jsi/RuntimeAwareCache.cpp"        
-        "${PROJECT_SOURCE_DIR}/cpp/jsi/JsiPromises.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiHostObject.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiValue.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeLifecycleMonitor.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/RuntimeAwareCache.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/jsi/JsiPromises.cpp"
 
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkManager.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkJsView.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDomView.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDispatchQueue.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkManager.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkJsView.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkDomView.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkDispatchQueue.cpp"
 
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/dom/base/DrawingContext.cpp"
-        "${PROJECT_SOURCE_DIR}/cpp/rnskia/dom/base/ConcatablePaint.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/dom/base/DrawingContext.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/dom/base/ConcatablePaint.cpp"
 
-        "${PROJECT_SOURCE_DIR}/cpp/api/third_party/CSSColorParser.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
 
 )
 
@@ -75,27 +75,28 @@ target_include_directories(
         "${NODE_MODULES_DIR}/react-native/ReactCommon/react/nativemodule/core"
         "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/jni"
 
-        cpp/skia/include/config/
-        cpp/skia/include/core/
-        cpp/skia/include/effects/
-        cpp/skia/include/utils/
-        cpp/skia/include/pathops/
-        cpp/skia/modules/
-        #cpp/skia/modules/skparagraph/include/
-        cpp/skia/include/
-        cpp/skia
-
-        cpp/api
-        cpp/jsi
         cpp/jni/include
         cpp/rnskia-android
-        cpp/rnskia
-        cpp/rnskia/values
-        cpp/rnskia/dom
-        cpp/rnskia/dom/base
-        cpp/rnskia/dom/nodes
-        cpp/rnskia/dom/props
-        cpp/utils
+
+        ../cpp/skia/include/config/
+        ../cpp/skia/include/core/
+        ../cpp/skia/include/effects/
+        ../cpp/skia/include/utils/
+        ../cpp/skia/include/pathops/
+        ../cpp/skia/modules/
+        #cpp/skia/modules/skparagraph/include/
+        ../cpp/skia/include/
+        ../cpp/skia
+
+        ../cpp/api
+        ../cpp/jsi
+        ../cpp/rnskia
+        ../cpp/rnskia/values
+        ../cpp/rnskia/dom
+        ../cpp/rnskia/dom/base
+        ../cpp/rnskia/dom/nodes
+        ../cpp/rnskia/dom/props
+        ../cpp/utils
 
         ${libfbjni_include_DIRS}
 )

package/android/cpp/rnskia-android/SkiaOpenGLRenderer.cpp

@@ -4,6 +4,8 @@
 #include <android/native_window.h>
 #include <android/native_window_jni.h>
 
+#pragma clang diagnostic push
+
 #define STENCIL_BUFFER_SIZE 8
 
 namespace RNSkia {
@@ -102,7 +104,7 @@ sk_sp<SkSurface> MakeOffscreenGLSurface(int width, int height) {
   };
   auto ctx = new OffscreenRenderContext({eglDisplay, eglSurface});
 
-  auto surface = SkSurface::MakeFromBackendRenderTarget(
+  auto surface = SkSurfaces::WrapBackendRenderTarget(
       grContext.get(), renderTarget, kBottomLeft_GrSurfaceOrigin,
       kRGBA_8888_SkColorType, nullptr, nullptr,
       [](void *addr) {
@@ -170,7 +172,7 @@ bool SkiaOpenGLRenderer::run(const std::function<void(SkCanvas *)> &cb,
 
       SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
 
-      sk_sp<SkSurface> renderTarget(SkSurface::MakeFromBackendRenderTarget(
+      sk_sp<SkSurface> renderTarget(SkSurfaces::WrapBackendRenderTarget(
           getThreadDrawingContext()->skContext.get(), backendRT,
           kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props));
 

package/android/cpp/rnskia-android/SkiaOpenGLRenderer.h

@@ -20,7 +20,10 @@
 #include "SkColorSpace.h"
 #include "SkPicture.h"
 #include "SkSurface.h"
+
+#include "include/gpu/GrBackendSurface.h"
 #include "include/gpu/GrDirectContext.h"
+#include "include/gpu/ganesh/SkSurfaceGanesh.h"
 #include "include/gpu/gl/GrGLInterface.h"
 
 #pragma clang diagnostic pop

package/cpp/api/JsiSkShaderFactory.h

@@ -169,8 +169,8 @@ public:
     auto tileW = arguments[4].asNumber();
     auto tileH = arguments[5].asNumber();
     SkISize size = SkISize::Make(tileW, tileH);
-    sk_sp<SkShader> gradient = SkPerlinNoiseShader::MakeTurbulence(
-        baseFreqX, baseFreqY, octaves, seed, &size);
+    sk_sp<SkShader> gradient =
+        SkShaders::MakeTurbulence(baseFreqX, baseFreqY, octaves, seed, &size);
     return jsi::Object::createFromHostObject(
         runtime,
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));
@@ -184,8 +184,8 @@ public:
     auto tileW = arguments[4].asNumber();
     auto tileH = arguments[5].asNumber();
     SkISize size = SkISize::Make(tileW, tileH);
-    sk_sp<SkShader> gradient = SkPerlinNoiseShader::MakeFractalNoise(
-        baseFreqX, baseFreqY, octaves, seed, &size);
+    sk_sp<SkShader> gradient =
+        SkShaders::MakeFractalNoise(baseFreqX, baseFreqY, octaves, seed, &size);
     return jsi::Object::createFromHostObject(
         runtime,
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));

package/cpp/api/JsiSkSurfaceFactory.h

@@ -25,7 +25,8 @@ public:
   JSI_HOST_FUNCTION(Make) {
     auto width = static_cast<int>(arguments[0].asNumber());
     auto height = static_cast<int>(arguments[1].asNumber());
-    auto surface = SkSurface::MakeRasterN32Premul(width, height);
+    auto imageInfo = SkImageInfo::MakeN32Premul(width, height);
+    auto surface = SkSurfaces::Raster(imageInfo);
     if (surface == nullptr) {
       return jsi::Value::null();
     }

package/cpp/rnskia/dom/nodes/JsiShaderNodes.h

@@ -256,7 +256,7 @@ public:
     SkISize size = SkISize::Make(_tileWidthProp->value().getAsNumber(),
                                  _tileHeightProp->value().getAsNumber());
 
-    context->getShaders()->push(SkPerlinNoiseShader::MakeTurbulence(
+    context->getShaders()->push(SkShaders::MakeTurbulence(
         _freqXProp->value().getAsNumber(), _freqYProp->value().getAsNumber(),
         _octavesProp->value().getAsNumber(), _seedProp->value().getAsNumber(),
         &size));
@@ -274,7 +274,7 @@ public:
     SkISize size = SkISize::Make(_tileWidthProp->value().getAsNumber(),
                                  _tileHeightProp->value().getAsNumber());
 
-    context->getShaders()->push(SkPerlinNoiseShader::MakeFractalNoise(
+    context->getShaders()->push(SkShaders::MakeFractalNoise(
         _freqXProp->value().getAsNumber(), _freqYProp->value().getAsNumber(),
         _octavesProp->value().getAsNumber(), _seedProp->value().getAsNumber(),
         &size));

package/cpp/skia/include/android/SkCanvasAndroid.h

@@ -0,0 +1,20 @@
+/*
+ * 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 SkCanvasAndroid_DEFINED
+#define SkCanvasAndroid_DEFINED
+
+class SkCanvas;
+struct SkIRect;
+class GrBackendRenderTarget;
+
+namespace skgpu::ganesh {
+SkIRect TopLayerBounds(const SkCanvas*);
+GrBackendRenderTarget TopLayerBackendRenderTarget(const SkCanvas*);
+}
+
+#endif

package/cpp/skia/include/android/SkHeifDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * 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 SkHeifDecoder_DEFINED
+#define SkHeifDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkHeifDecoder {
+
+/** Returns true if this data claims to be a HEIF image. */
+SK_API bool IsHeif(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a HEIF.
+ *
+ *  If the bytes are not a HEIF, returns nullptr.
+ *
+ *  DecodeContext is treated as a SkCodec::SelectionPolicy*
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "heif", IsHeif, Decode };
+}
+
+}  // namespace SkHeifDecoder
+
+#endif  // SkHeifDecoder_DEFINED

package/cpp/skia/include/android/SkSurfaceAndroid.h

@@ -0,0 +1,50 @@
+/*
+ * 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 SkSurfaceAndroid_DEFINED
+#define SkSurfaceAndroid_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/GrTypes.h"
+
+class SkColorSpace;
+class GrDirectContext;
+class SkPixmap;
+struct AHardwareBuffer;
+
+namespace SkSurfaces {
+
+/** Private; only to be used by Android Framework.
+    Creates SkSurface from Android hardware buffer.
+    Returned SkSurface takes a reference on the buffer. The ref on the buffer will be released
+    when the SkSurface is destroyed and there is no pending work on the GPU involving the
+    buffer.
+
+    Currently this is only supported for buffers that can be textured as well as rendered to.
+    In other words that must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and
+    AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.
+
+    @param context         GPU context
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param colorSpace      range of colors; may be nullptr
+    @param surfaceProps    LCD striping orientation and setting for device independent
+                           fonts; may be nullptr
+    @param fromWindow      Whether or not the AHardwareBuffer is part of an Android Window.
+                           Currently only used with Vulkan backend.
+    @return                created SkSurface, or nullptr
+*/
+SK_API sk_sp<SkSurface> WrapAndroidHardwareBuffer(GrDirectContext* context,
+                                                  AHardwareBuffer* hardwareBuffer,
+                                                  GrSurfaceOrigin origin,
+                                                  sk_sp<SkColorSpace> colorSpace,
+                                                  const SkSurfaceProps* surfaceProps,
+                                                  bool fromWindow = false);
+
+}  // namespace SkSurfaces
+
+#endif

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkAvifDecoder_DEFINED
+#define SkAvifDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkAvifDecoder {
+
+/** Returns true if this data claims to be a AVIF image. */
+SK_API bool IsAvif(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a AVIF.
+ *
+ *  If the bytes are not a AVIF, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "avif", IsAvif, Decode };
+}
+
+}  // namespace SkAvifDecoder
+
+#endif  // SkAvifDecoder_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkBmpDecoder_DEFINED
+#define SkBmpDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkBmpDecoder {
+
+/** Returns true if this data claims to be a BMP image. */
+SK_API bool IsBmp(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a BMP.
+ *
+ *  If the bytes are not a BMP, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "bmp", IsBmp, Decode };
+}
+
+}  // namespace SkBmpDecoder
+
+#endif  // SkBmpDecoder_DEFINED

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

@@ -23,6 +23,7 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
+#include <string>
 #include <tuple>
 #include <vector>
 
@@ -41,7 +42,6 @@ enum class Blend;
 enum class DisposalMethod;
 }
 
-
 namespace DM {
 class CodecSrc;
 } // namespace DM
@@ -1012,4 +1012,28 @@ private:
     friend class SkIcoCodec;
     friend class SkAndroidCodec; // for fEncodedInfo
 };
+
+namespace SkCodecs {
+
+using DecodeContext = void*;
+using IsFormatCallback = bool (*)(const void* data, size_t len);
+using MakeFromStreamCallback = std::unique_ptr<SkCodec> (*)(std::unique_ptr<SkStream>,
+                                                            SkCodec::Result*,
+                                                            DecodeContext);
+
+struct Decoder {
+    // By convention, we use all lowercase letters and go with the primary filename extension.
+    // For example "png", "jpg", "ico", "webp", etc
+    std::string id;
+    IsFormatCallback isFormat;
+    MakeFromStreamCallback makeFromStream;
+};
+
+// Add the decoder to the end of a linked list of decoders, which will be used to identify calls to
+// SkCodec::MakeFromStream. If a decoder with the same id already exists, this new decoder
+// will replace the existing one (in the same position). This is not thread-safe, so make sure all
+// initialization is done before the first call.
+void Register(Decoder d);
+}
+
 #endif // SkCodec_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkGifDecoder_DEFINED
+#define SkGifDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkGifDecoder {
+
+/** Returns true if this data claims to be a GIF image. */
+SK_API bool IsGif(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a GIF.
+ *
+ *  If the bytes are not a GIF, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "gif", IsGif, Decode };
+}
+
+}  // namespace SkGifDecoder
+
+#endif  // SkGifDecoder_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkIcoDecoder_DEFINED
+#define SkIcoDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkIcoDecoder {
+
+/** Returns true if this data claims to be a ICO image. */
+SK_API bool IsIco(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a ICO.
+ *
+ *  If the bytes are not a ICO, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "ico", IsIco, Decode };
+}
+
+}  // namespace SkIcoDecoder
+
+#endif  // SkIcoDecoder_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkJpegDecoder_DEFINED
+#define SkJpegDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkJpegDecoder {
+
+/** Returns true if this data claims to be a JPEG image. */
+SK_API bool IsJpeg(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a JPEG.
+ *
+ *  If the bytes are not a JPEG, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "jpeg", IsJpeg, Decode };
+}
+
+}  // namespace SkJpegDecoder
+
+#endif  // SkJpegDecoder_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkJpegxlDecoder_DEFINED
+#define SkJpegxlDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkJpegxlDecoder {
+
+/** Returns true if this data claims to be a JPEGXL image. */
+SK_API bool IsJpegxl(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a JPEGXL.
+ *
+ *  If the bytes are not a JPEGXL, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "jpegxl", IsJpegxl, Decode };
+}
+
+}  // namespace SkJpegxlDecoder
+
+#endif  // SkJpegxlDecoder_DEFINED

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

@@ -0,0 +1,43 @@
+/*
+ * 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 SkPngDecoder_DEFINED
+#define SkPngDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkPngDecoder {
+
+/** Returns true if this data claims to be a PNG image. */
+SK_API bool IsPng(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a PNG.
+ *
+ *  If the bytes are not a PNG, returns nullptr.
+ *
+ *  DecodeContext, if non-null, is expected to be a SkPngChunkReader*
+ */
+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>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "png", IsPng, Decode };
+}
+
+}  // namespace SkPngDecoder
+
+#endif  // SkPngDecoder_DEFINED