rngine 0.7.2 → 0.8.1

package/shared/skia/include/codec/SkCodecAnimation.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCodecAnimation_DEFINED
+#define SkCodecAnimation_DEFINED
+
+namespace SkCodecAnimation {
+    /**
+     *  This specifies how the next frame is based on this frame.
+     *
+     *  Names are based on the GIF 89a spec.
+     *
+     *  The numbers correspond to values in a GIF.
+     */
+    enum class DisposalMethod {
+        /**
+         *  The next frame should be drawn on top of this one.
+         *
+         *  In a GIF, a value of 0 (not specified) is also treated as Keep.
+         */
+        kKeep               = 1,
+
+        /**
+         *  Similar to Keep, except the area inside this frame's rectangle
+         *  should be cleared to the BackGround color (transparent) before
+         *  drawing the next frame.
+         */
+        kRestoreBGColor     = 2,
+
+        /**
+         *  The next frame should be drawn on top of the previous frame - i.e.
+         *  disregarding this one.
+         *
+         *  In a GIF, a value of 4 is also treated as RestorePrevious.
+         */
+        kRestorePrevious    = 3,
+    };
+
+    /**
+     * How to blend the current frame.
+     */
+    enum class Blend {
+        /**
+         *  Blend with the prior frame as if using SkBlendMode::kSrcOver.
+         */
+        kSrcOver,
+
+        /**
+         *  Blend with the prior frame as if using SkBlendMode::kSrc.
+         *
+         *  This frame's pixels replace the destination pixels.
+         */
+        kSrc,
+    };
+
+} // namespace SkCodecAnimation
+#endif // SkCodecAnimation_DEFINED

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

@@ -0,0 +1,33 @@
+/*
+ * 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 {
+    kBMP,
+    kGIF,
+    kICO,
+    kJPEG,
+    kPNG,
+    kWBMP,
+    kWEBP,
+    kPKM,
+    kKTX,
+    kASTC,
+    kDNG,
+    kHEIF,
+    kAVIF,
+    kJPEGXL,
+};
+
+#endif  // SkEncodedImageFormat_DEFINED

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkEncodedOrigin_DEFINED
+#define SkEncodedOrigin_DEFINED
+
+#include "include/core/SkMatrix.h"
+
+// These values match the orientation www.exif.org/Exif2-2.PDF.
+enum SkEncodedOrigin {
+    kTopLeft_SkEncodedOrigin     = 1, // Default
+    kTopRight_SkEncodedOrigin    = 2, // Reflected across y-axis
+    kBottomRight_SkEncodedOrigin = 3, // Rotated 180
+    kBottomLeft_SkEncodedOrigin  = 4, // Reflected across x-axis
+    kLeftTop_SkEncodedOrigin     = 5, // Reflected across x-axis, Rotated 90 CCW
+    kRightTop_SkEncodedOrigin    = 6, // Rotated 90 CW
+    kRightBottom_SkEncodedOrigin = 7, // Reflected across x-axis, Rotated 90 CW
+    kLeftBottom_SkEncodedOrigin  = 8, // Rotated 90 CCW
+    kDefault_SkEncodedOrigin     = kTopLeft_SkEncodedOrigin,
+    kLast_SkEncodedOrigin        = kLeftBottom_SkEncodedOrigin,
+};
+
+/**
+ * Given an encoded origin and the width and height of the source data, returns a matrix
+ * that transforms the source rectangle with upper left corner at [0, 0] and origin to a correctly
+ * oriented destination rectangle of [0, 0, w, h].
+ */
+static inline SkMatrix SkEncodedOriginToMatrix(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, w,  1,  0, 0, 0, 0, 1);
+        case kRightBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0, -1, w, -1,  0, h, 0, 0, 1);
+        case  kLeftBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0,  1, 0, -1,  0, h, 0, 0, 1);
+    }
+    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.
+ */
+static inline bool SkEncodedOriginSwapsWidthHeight(SkEncodedOrigin origin) {
+    return origin >= kLeftTop_SkEncodedOrigin;
+}
+
+#endif // SkEncodedOrigin_DEFINED

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

@@ -0,0 +1,44 @@
+/*
+ * 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"
+#include "include/private/SkAPI.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<const SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "gif", IsGif, Decode };
+}
+
+}  // namespace SkGifDecoder
+
+#endif  // SkGifDecoder_DEFINED

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

@@ -0,0 +1,44 @@
+/*
+ * 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"
+#include "include/private/SkAPI.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<const SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "ico", IsIco, Decode };
+}
+
+}  // namespace SkIcoDecoder
+
+#endif  // SkIcoDecoder_DEFINED

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

@@ -0,0 +1,51 @@
+/*
+ * 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"
+#include "include/private/SkAPI.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<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 };
+}
+
+}  // namespace SkJpegDecoder
+
+#endif  // SkJpegDecoder_DEFINED

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

@@ -0,0 +1,44 @@
+/*
+ * 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"
+#include "include/private/SkAPI.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<const SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "jpegxl", IsJpegxl, Decode };
+}
+
+}  // namespace SkJpegxlDecoder
+
+#endif  // SkJpegxlDecoder_DEFINED

package/shared/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/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/shared/skia/include/codec/SkPngChunkReader.h

@@ -0,0 +1,45 @@
+/*
+ * 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 SkPngChunkReader_DEFINED
+#define SkPngChunkReader_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+/**
+ *  SkPngChunkReader
+ *
+ *  Base class for optional callbacks to retrieve meta/chunk data out of a PNG
+ *  encoded image as it is being decoded.
+ *  Used by SkCodec.
+ */
+class SkPngChunkReader : public SkRefCnt {
+public:
+    /**
+     *  This will be called by the decoder when it sees an unknown chunk.
+     *
+     *  Use by SkCodec:
+     *  Depending on the location of the unknown chunks, this callback may be
+     *  called by
+     *      - the factory (NewFromStream/NewFromData)
+     *      - getPixels
+     *      - startScanlineDecode
+     *      - the first call to getScanlines/skipScanlines
+     *  The callback may be called from a different thread (e.g. if the SkCodec
+     *  is passed to another thread), and it may be called multiple times, if
+     *  the SkCodec is used multiple times.
+     *
+     *  @param tag Name for this type of chunk.
+     *  @param data Data to be interpreted by the subclass.
+     *  @param length Number of bytes of data in the chunk.
+     *  @return true to continue decoding, or false to indicate an error, which
+     *      will cause the decoder to not return the image.
+     */
+    virtual bool readChunk(const char tag[], const void* data, size_t length) = 0;
+};
+#endif // SkPngChunkReader_DEFINED

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

@@ -0,0 +1,51 @@
+/*
+ * 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"
+#include "include/private/SkAPI.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<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 { "png", IsPng, Decode };
+}
+
+}  // namespace SkPngDecoder
+
+#endif  // SkPngDecoder_DEFINED

package/shared/skia/include/codec/SkPngRustDecoder.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPngRustDecoder_DEFINED
+#define SkPngRustDecoder_DEFINED
+
+#include <memory>
+
+#include "include/codec/SkCodec.h"
+#include "include/private/SkAPI.h"
+
+class SkStream;
+
+namespace SkPngRustDecoder {
+
+/** Returns true if this data claims to be a PNG image. */
+SK_API bool IsPng(const void*, size_t);
+
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() { return {"png", IsPng, Decode}; }
+
+}  // namespace SkPngRustDecoder
+
+#endif  // SkPngRustDecoder_DEFINED

package/shared/skia/include/codec/SkRawDecoder.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 SkRawDecoder_DEFINED
+#define SkRawDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkRawDecoder {
+
+inline bool IsRaw(const void*, size_t) {
+    // Raw formats are tricky to detect just by reading in the first several bytes.
+    // For example, PIEX might need to read 10k bytes to detect Sony's arw format
+    // https://github.com/google/piex/blob/f1e15dd837c04347504149f71db67a78fbeddc73/src/image_type_recognition/image_type_recognition_lite.cc#L152
+    // Thus, we just assume everything might be a RAW file and check it last.
+    return true;
+}
+
+/**
+ *  Attempts to decode the given bytes as a raw image.
+ *
+ *  If the bytes are not a raw, 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<const SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+// This decoder will always be checked last, no matter when it is registered.
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "raw", IsRaw, Decode };
+}
+
+}  // namespace SkRawDecoder
+
+#endif  // SkRawDecoder_DEFINED

package/shared/skia/include/codec/SkWbmpDecoder.h

@@ -0,0 +1,44 @@
+/*
+ * 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 SkWbmpDecoder_DEFINED
+#define SkWbmpDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkWbmpDecoder {
+
+/** Returns true if this data claims to be a WBMP image. */
+SK_API bool IsWbmp(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a WBMP.
+ *
+ *  If the bytes are not a WBMP, 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<const SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "wbmp", IsWbmp, Decode };
+}
+
+}  // namespace SkWbmpDecoder
+
+#endif  // SkWbmpDecoder_DEFINED

package/shared/skia/include/codec/SkWebpDecoder.h

@@ -0,0 +1,51 @@
+/*
+ * 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 SkWebpDecoder_DEFINED
+#define SkWebpDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkWebpDecoder {
+
+/** Returns true if this data claims to be a WEBP image. */
+SK_API bool IsWebp(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a WEBP.
+ *
+ *  If the bytes are not a WEBP, 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<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 { "webp", IsWebp, Decode };
+}
+
+}  // namespace SkWebpDecoder
+
+#endif  // SkWebpDecoder_DEFINED