rngine 0.7.2 → 0.8.1

package/shared/skia/include/core/SkYUVAPixmaps.h

@@ -0,0 +1,335 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkYUVAPixmaps_DEFINED
+#define SkYUVAPixmaps_DEFINED
+
+#include "include/core/SkColorType.h"
+#include "include/core/SkData.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/private/SkTo.h"
+
+#include <array>
+#include <bitset>
+#include <cstddef>
+#include <tuple>
+
+/**
+ * SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps
+ * for a YUVA image without the actual pixel memory and data.
+ */
+class SK_API SkYUVAPixmapInfo {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    using PlaneConfig  = SkYUVAInfo::PlaneConfig;
+    using Subsampling  = SkYUVAInfo::Subsampling;
+
+    /**
+     * Data type for Y, U, V, and possibly A channels independent of how values are packed into
+     * planes.
+     **/
+    enum class DataType {
+        kUnorm8,          ///< 8 bit unsigned normalized
+        kUnorm16,         ///< 16 bit unsigned normalized
+        kFloat16,         ///< 16 bit (half) floating point
+        kUnorm10_Unorm2,  ///< 10 bit unorm for Y, U, and V. 2 bit unorm for alpha (if present).
+
+        kLast = kUnorm10_Unorm2
+    };
+    static constexpr int kDataTypeCnt = static_cast<int>(DataType::kLast) + 1;
+
+    class SK_API SupportedDataTypes {
+    public:
+        /** Defaults to nothing supported. */
+        constexpr SupportedDataTypes() = default;
+
+        /** All legal combinations of PlaneConfig and DataType are supported. */
+        static constexpr SupportedDataTypes All();
+
+        /**
+         * Checks whether there is a supported combination of color types for planes structured
+         * as indicated by PlaneConfig with channel data types as indicated by DataType.
+         */
+        constexpr bool supported(PlaneConfig, DataType) const;
+
+        /**
+         * Update to add support for pixmaps with numChannel channels where each channel is
+         * represented as DataType.
+         */
+        void enableDataType(DataType, int numChannels);
+
+    private:
+        // The bit for DataType dt with n channels is at index kDataTypeCnt*(n-1) + dt.
+        std::bitset<kDataTypeCnt*4> fDataTypeSupport = {};
+    };
+
+    /**
+     * Gets the default SkColorType to use with numChannels channels, each represented as DataType.
+     * Returns kUnknown_SkColorType if no such color type.
+     */
+    static constexpr SkColorType DefaultColorTypeForDataType(DataType dataType, int numChannels);
+
+    /**
+     * If the SkColorType is supported for YUVA pixmaps this will return the number of YUVA channels
+     * that can be stored in a plane of this color type and what the DataType is of those channels.
+     * If the SkColorType is not supported as a YUVA plane the number of channels is reported as 0
+     * and the DataType returned should be ignored.
+     */
+    static std::tuple<int, DataType> NumChannelsAndDataType(SkColorType);
+
+    /** Default SkYUVAPixmapInfo is invalid. */
+    SkYUVAPixmapInfo() = default;
+
+    /**
+     * Initializes the SkYUVAPixmapInfo from a SkYUVAInfo with per-plane color types and row bytes.
+     * This will be invalid if the colorTypes aren't compatible with the SkYUVAInfo or if a
+     * rowBytes entry is not valid for the plane dimensions and color type. Color type and
+     * row byte values beyond the number of planes in SkYUVAInfo are ignored. All SkColorTypes
+     * must have the same DataType or this will be invalid.
+     *
+     * If rowBytes is nullptr then bpp*width is assumed for each plane.
+     */
+    SkYUVAPixmapInfo(const SkYUVAInfo&,
+                     const SkColorType[kMaxPlanes],
+                     const size_t rowBytes[kMaxPlanes]);
+    /**
+     * Like above but uses DefaultColorTypeForDataType to determine each plane's SkColorType. If
+     * rowBytes is nullptr then bpp*width is assumed for each plane.
+     */
+    SkYUVAPixmapInfo(const SkYUVAInfo&, DataType, const size_t rowBytes[kMaxPlanes]);
+
+    SkYUVAPixmapInfo(const SkYUVAPixmapInfo&) = default;
+
+    SkYUVAPixmapInfo& operator=(const SkYUVAPixmapInfo&) = default;
+
+    bool operator==(const SkYUVAPixmapInfo&) const;
+    bool operator!=(const SkYUVAPixmapInfo& that) const { return !(*this == that); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    /** The number of SkPixmap planes, 0 if this SkYUVAPixmapInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /** The per-YUV[A] channel data type. */
+    DataType dataType() const { return fDataType; }
+
+    /**
+     * Row bytes for the ith plane. Returns zero if this SkYUVAPixmapInfo is invalid.
+     */
+    size_t rowBytes(int i) const { return fRowBytes[static_cast<size_t>(i)]; }
+
+    /** Image info for the ith plane */
+    const SkImageInfo& planeInfo(int i) const { return fPlaneInfos[static_cast<size_t>(i)]; }
+
+    /**
+     * Determine size to allocate for all planes. Optionally retrieves the per-plane sizes in
+     * planeSizes if not null. If total size overflows will return SIZE_MAX and set all planeSizes
+     * to SIZE_MAX. Returns 0 and fills planesSizes with 0 if this SkYUVAPixmapInfo is not valid.
+     */
+    size_t computeTotalBytes(size_t planeSizes[kMaxPlanes] = nullptr) const;
+
+    /**
+     * Takes an allocation that is assumed to be at least computeTotalBytes() in size and configures
+     * the first numPlanes() entries in pixmaps array to point into that memory. The remaining
+     * entries of pixmaps are default initialized. Fails if this SkYUVAPixmapInfo not valid.
+     */
+    bool initPixmapsFromSingleAllocation(void* memory, SkPixmap pixmaps[kMaxPlanes]) const;
+
+    /**
+     * Returns true if this has been configured with a non-empty dimensioned SkYUVAInfo with
+     * compatible color types and row bytes.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /** Is this valid and does it use color types allowed by the passed SupportedDataTypes? */
+    bool isSupported(const SupportedDataTypes&) const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<SkImageInfo, kMaxPlanes> fPlaneInfos = {};
+    std::array<size_t, kMaxPlanes> fRowBytes = {};
+    DataType fDataType = DataType::kUnorm8;
+    static_assert(kUnknown_SkColorType == 0, "default init isn't kUnknown");
+};
+
+/**
+ * Helper to store SkPixmap planes as described by a SkYUVAPixmapInfo. Can be responsible for
+ * allocating/freeing memory for pixmaps or use external memory.
+ */
+class SK_API SkYUVAPixmaps {
+public:
+    using DataType = SkYUVAPixmapInfo::DataType;
+    static constexpr auto kMaxPlanes = SkYUVAPixmapInfo::kMaxPlanes;
+
+    static SkColorType RecommendedRGBAColorType(DataType);
+
+    /** Allocate space for pixmaps' pixels in the SkYUVAPixmaps. */
+    static SkYUVAPixmaps Allocate(const SkYUVAPixmapInfo& yuvaPixmapInfo);
+
+    /**
+     * Use storage in SkData as backing store for pixmaps' pixels. SkData is retained by the
+     * SkYUVAPixmaps.
+     */
+    static SkYUVAPixmaps FromData(const SkYUVAPixmapInfo&, sk_sp<SkData>);
+
+    /**
+     * Makes a deep copy of the src SkYUVAPixmaps. The returned SkYUVAPixmaps owns its planes'
+     * backing stores.
+     */
+    static SkYUVAPixmaps MakeCopy(const SkYUVAPixmaps& src);
+
+    /**
+     * Use passed in memory as backing store for pixmaps' pixels. Caller must ensure memory remains
+     * allocated while pixmaps are in use. There must be at least
+     * SkYUVAPixmapInfo::computeTotalBytes() allocated starting at memory.
+     */
+    static SkYUVAPixmaps FromExternalMemory(const SkYUVAPixmapInfo&, void* memory);
+
+    /**
+     * Wraps existing SkPixmaps. The SkYUVAPixmaps will have no ownership of the SkPixmaps' pixel
+     * memory so the caller must ensure it remains valid. Will return an invalid SkYUVAPixmaps if
+     * the SkYUVAInfo isn't compatible with the SkPixmap array (number of planes, plane dimensions,
+     * sufficient color channels in planes, ...).
+     */
+    static SkYUVAPixmaps FromExternalPixmaps(const SkYUVAInfo&, const SkPixmap[kMaxPlanes]);
+
+    /** Default SkYUVAPixmaps is invalid. */
+    SkYUVAPixmaps() = default;
+    ~SkYUVAPixmaps() = default;
+
+    SkYUVAPixmaps(SkYUVAPixmaps&& that) = default;
+    SkYUVAPixmaps& operator=(SkYUVAPixmaps&& that) = default;
+    SkYUVAPixmaps(const SkYUVAPixmaps&) = default;
+    SkYUVAPixmaps& operator=(const SkYUVAPixmaps& that) = default;
+
+    /** Does have initialized pixmaps compatible with its SkYUVAInfo. */
+    bool isValid() const { return !fYUVAInfo.dimensions().isEmpty(); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    DataType dataType() const { return fDataType; }
+
+    SkYUVAPixmapInfo pixmapsInfo() const;
+
+    /** Number of pixmap planes or 0 if this SkYUVAPixmaps is invalid. */
+    int numPlanes() const { return this->isValid() ? fYUVAInfo.numPlanes() : 0; }
+
+    /**
+     * Access the SkPixmap planes. They are default initialized if this is not a valid
+     * SkYUVAPixmaps.
+     */
+    const std::array<SkPixmap, kMaxPlanes>& planes() const { return fPlanes; }
+
+    /**
+     * Get the ith SkPixmap plane. SkPixmap will be default initialized if SkYUVAPixmaps is invalid.
+     */
+    const SkPixmap& plane(int i) const { return fPlanes[SkToSizeT(i)]; }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+    /** Does this SkPixmaps own the backing store of the planes? */
+    bool ownsStorage() const { return SkToBool(fData); }
+
+private:
+    SkYUVAPixmaps(const SkYUVAPixmapInfo&, sk_sp<SkData>);
+    SkYUVAPixmaps(const SkYUVAInfo&, DataType, const SkPixmap[kMaxPlanes]);
+
+    std::array<SkPixmap, kMaxPlanes> fPlanes = {};
+    sk_sp<SkData> fData;
+    SkYUVAInfo fYUVAInfo;
+    DataType fDataType;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+constexpr SkYUVAPixmapInfo::SupportedDataTypes SkYUVAPixmapInfo::SupportedDataTypes::All() {
+    using ULL = unsigned long long; // bitset cons. takes this.
+    ULL bits = 0;
+    for (ULL c = 1; c <= 4; ++c) {
+        for (ULL dt = 0; dt <= ULL(kDataTypeCnt); ++dt) {
+            if (DefaultColorTypeForDataType(static_cast<DataType>(dt),
+                                            static_cast<int>(c)) != kUnknown_SkColorType) {
+                bits |= ULL(1) << (dt + static_cast<ULL>(kDataTypeCnt)*(c - 1));
+            }
+        }
+    }
+    SupportedDataTypes combinations;
+    combinations.fDataTypeSupport = bits;
+    return combinations;
+}
+
+constexpr bool SkYUVAPixmapInfo::SupportedDataTypes::supported(PlaneConfig config,
+                                                               DataType type) const {
+    int n = SkYUVAInfo::NumPlanes(config);
+    for (int i = 0; i < n; ++i) {
+        auto c = static_cast<size_t>(SkYUVAInfo::NumChannelsInPlane(config, i));
+        SkASSERT(c >= 1 && c <= 4);
+        if (!fDataTypeSupport[static_cast<size_t>(type) +
+                              (c - 1)*static_cast<size_t>(kDataTypeCnt)]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+constexpr SkColorType SkYUVAPixmapInfo::DefaultColorTypeForDataType(DataType dataType,
+                                                                    int numChannels) {
+    switch (numChannels) {
+        case 1:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kGray_8_SkColorType;
+                case DataType::kUnorm16:        return kA16_unorm_SkColorType;
+                case DataType::kFloat16:        return kA16_float_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
+            }
+            break;
+        case 2:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kR8G8_unorm_SkColorType;
+                case DataType::kUnorm16:        return kR16G16_unorm_SkColorType;
+                case DataType::kFloat16:        return kR16G16_float_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
+            }
+            break;
+        case 3:
+            // None of these are tightly packed. The intended use case is for interleaved YUVA
+            // planes where we're forcing opaqueness by ignoring the alpha values.
+            // There are "x" rather than "A" variants for Unorm8 and Unorm10_Unorm2 but we don't
+            // choose them because 1) there is no inherent advantage and 2) there is better support
+            // in the GPU backend for the "A" versions.
+            switch (dataType) {
+                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
+                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
+                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
+            }
+            break;
+        case 4:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
+                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
+                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
+            }
+            break;
+    }
+    return kUnknown_SkColorType;
+}
+
+#endif

package/shared/skia/include/docs/SkMultiPictureDocument.h

@@ -0,0 +1,53 @@
+/*
+ * 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 SkMultiPictureDocument_DEFINED
+#define SkMultiPictureDocument_DEFINED
+
+#include "include/core/SkPicture.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+
+#include <functional>
+
+class SkDocument;
+class SkStreamSeekable;
+class SkWStream;
+struct SkDeserialProcs;
+struct SkSerialProcs;
+
+struct SkDocumentPage {
+    sk_sp<SkPicture> fPicture;
+    SkSize fSize;
+};
+
+namespace SkMultiPictureDocument {
+/**
+ *  Writes into a file format that is similar to SkPicture::serialize()
+ *  Accepts a callback for endPage behavior
+ */
+SK_API sk_sp<SkDocument> Make(SkWStream* dst, const SkSerialProcs* = nullptr,
+                              std::function<void(const SkPicture*)> onEndPage = nullptr);
+
+/**
+ *  Returns the number of pages in the SkMultiPictureDocument.
+ */
+SK_API int ReadPageCount(SkStreamSeekable* src);
+
+/**
+ *  Read the SkMultiPictureDocument into the provided array of pages.
+ *  dstArrayCount must equal SkMultiPictureDocumentReadPageCount().
+ *  Return false on error.
+ */
+SK_API bool Read(SkStreamSeekable* src,
+                 SkDocumentPage* dstArray,
+                 int dstArrayCount,
+                 const SkDeserialProcs* = nullptr);
+}  // namespace SkMultiPictureDocument
+
+#endif  // SkMultiPictureDocument_DEFINED

package/shared/skia/include/docs/SkPDFDocument.h

@@ -0,0 +1,277 @@
+// Copyright 2018 Google LLC
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+#ifndef SkPDFDocument_DEFINED
+#define SkPDFDocument_DEFINED
+
+#include "include/core/SkDocument.h"
+#include "include/core/SkMilestone.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkString.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkMacros.h"
+#include "include/private/SkNoncopyable.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+class SkCanvas;
+class SkCodec;
+class SkData;
+class SkExecutor;
+class SkPDFArray;
+class SkPDFStructTree;
+class SkPixmap;
+class SkWStream;
+
+namespace SkPDF {
+
+/** Attributes for nodes in the PDF tree.
+ *
+ * Each attribute must have an owner (e.g. "Layout", "List", "Table", etc)
+ * and an attribute name (e.g. "BBox", "RowSpan", etc.) from PDF32000_2008 14.8.5,
+ * and then a value of the proper type according to the spec.
+ *
+ * Parameters of type `const char*` will not be copied and the pointers must remain valid until
+ * `SkDocument::close` or `SkDocument::abort` is called.
+ * Names are expected to be constants and are taken as `const char*`.
+ * Parameters not taken as `const char*` will be copied.
+ */
+class SK_API AttributeList : SkNoncopyable {
+public:
+    AttributeList();
+    ~AttributeList();
+
+    void appendInt(const char* owner, const char* name, int value);
+    void appendFloat(const char* owner, const char* name, float value);
+    void appendName(const char* owner, const char* name, const char* value);
+    void appendTextString(const char* owner, const char* name, const char* value);
+    void appendTextString(const char* owner, const char* name, SkString value);
+    void appendFloatArray(const char* owner, const char* name, SkSpan<const float> value);
+    void appendNodeIdArray(const char* owner, const char* name, SkSpan<const int> nodeIds);
+
+private:
+    friend class ::SkPDFStructTree;
+
+    std::unique_ptr<SkPDFArray> fAttrs;
+    std::vector<int> fElemIds; // element identifiers referenced by fAttrs
+};
+
+/** A node in a PDF structure tree, giving a semantic representation
+    of the content.  Each node ID is associated with content
+    by passing the SkCanvas and node ID to SkPDF::SetNodeId() when drawing.
+    NodeIDs should be unique within each tree.
+*/
+struct StructureElementNode {
+    SkString fTypeString;
+    std::vector<std::unique_ptr<StructureElementNode>> fChildVector;
+    int fNodeId = 0;
+    AttributeList fAttributes;
+    SkString fAlt;
+    SkString fLang;
+};
+
+struct DateTime {
+    int16_t  fTimeZoneMinutes;  // The number of minutes that this
+                                // is ahead of or behind UTC.
+    uint16_t fYear;          //!< e.g. 2005
+    uint8_t  fMonth;         //!< 1..12
+    uint8_t  fDayOfWeek;     //!< 0..6, 0==Sunday
+    uint8_t  fDay;           //!< 1..31
+    uint8_t  fHour;          //!< 0..23
+    uint8_t  fMinute;        //!< 0..59
+    uint8_t  fSecond;        //!< 0..59
+
+    void toISO8601(SkString* dst) const;
+};
+
+using DecodeJpegCallback = std::unique_ptr<SkCodec> (*)(sk_sp<const SkData>);
+using EncodeJpegCallback = bool (*)(SkWStream* dst, const SkPixmap& src, int quality);
+
+/** Optional metadata to be passed into the PDF factory function.
+*/
+struct Metadata {
+    /** The document's title.
+    */
+    SkString fTitle;
+
+    /** The name of the person who created the document.
+    */
+    SkString fAuthor;
+
+    /** The subject of the document.
+    */
+    SkString fSubject;
+
+    /** Keywords associated with the document.  Commas may be used to delineate
+        keywords within the string.
+    */
+    SkString fKeywords;
+
+    /** If the document was converted to PDF from another format,
+        the name of the conforming product that created the
+        original document from which it was converted.
+    */
+    SkString fCreator;
+
+    /** The product that is converting this document to PDF.
+    */
+    SkString fProducer = SkString("Skia/PDF m" SK_MACRO_STRINGIFY(SK_MILESTONE));
+
+    /** The date and time the document was created.
+        The zero default value represents an unknown/unset time.
+    */
+    DateTime fCreation = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    /** The date and time the document was most recently modified.
+        The zero default value represents an unknown/unset time.
+    */
+    DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    /** The natural language of the text in the PDF. If fLang is empty, the root
+        StructureElementNode::fLang will be used (if not empty). Text not in
+        this language should be marked with StructureElementNode::fLang.
+    */
+    SkString fLang;
+
+    /** The DPI (pixels-per-inch) at which features without native PDF support
+        will be rasterized (e.g. draw image with perspective, draw text with
+        perspective, ...)  A larger DPI would create a PDF that reflects the
+        original intent with better fidelity, but it can make for larger PDF
+        files too, which would use more memory while rendering, and it would be
+        slower to be processed or sent online or to printer.
+    */
+    SkScalar fRasterDPI = SK_ScalarDefaultRasterDPI;
+
+    /** If true, include XMP metadata, a document UUID, and sRGB output intent
+        information.  This adds length to the document and makes it
+        non-reproducable, but are necessary features for PDF/A-2b conformance
+    */
+    bool fPDFA = false;
+
+    /** Encoding quality controls the trade-off between size and quality. By
+        default this is set to 101 percent, which corresponds to lossless
+        encoding. If this value is set to a value <= 100, and the image is
+        opaque, it will be encoded (using JPEG) with that quality setting.
+    */
+    int fEncodingQuality = 101;
+
+    /** If true, rasterize gradients with non-opaque stops for print compatibility.
+        Intended only for physical printing; it trades vector fidelity and file
+        size to avoid PDF-to-PostScript converter bugs.
+    */
+    bool fRasterizeAlphaGradientsForPrinting = false;
+
+    /** An optional tree of structured document tags that provide
+        a semantic representation of the content. The caller
+        should retain ownership.
+    */
+    StructureElementNode* fStructureElementTreeRoot = nullptr;
+
+    enum class Outline : int {
+        None = 0,
+        StructureElementHeaders = 1,
+        StructureElements = 2,
+    } fOutline = Outline::None;
+
+    /** Executor to handle threaded work within PDF Backend. If this is nullptr,
+        then all work will be done serially on the main thread. To have worker
+        threads assist with various tasks, set this to a valid SkExecutor
+        instance. Currently used for executing Deflate algorithm in parallel.
+
+        If set, the PDF output will be non-reproducible in the order and
+        internal numbering of objects, but should render the same.
+
+        Experimental.
+    */
+    SkExecutor* fExecutor = nullptr;
+
+    /** PDF streams may be compressed to save space.
+        Use this to specify the desired compression vs time tradeoff.
+    */
+    enum class CompressionLevel : int {
+        Default = -1,
+        None = 0,
+        LowButFast = 1,
+        Average = 6,
+        HighButSlow = 9,
+    } fCompressionLevel = CompressionLevel::Default;
+
+    /** Preferred Subsetter. */
+    enum Subsetter {
+        kHarfbuzz_Subsetter,
+    } fSubsetter = kHarfbuzz_Subsetter;
+
+    /** Clients can provide a way to decode jpeg. To use Skia's JPEG decoder, pass in
+        SkJpegDecoder::Decode. If not supplied, all images will need to be re-encoded
+        as jpegs or deflated images before embedding. If supplied, Skia may be able to
+        skip the re-encoding step.
+        Skia's JPEG decoder can be used here.
+    */
+    SkPDF::DecodeJpegCallback jpegDecoder = nullptr;
+
+    /** Clients can provide a way to encode jpeg. If not supplied, images will be embedded
+        as a deflated image, potentially making them much larger. If clients provide
+        their own implementation, JPEGs should be encoded to RGB (not YUV) otherwise they
+        will have the wrong surrounding metadata provided by Skia.
+        Skia's JPEG encoder can be used here.
+    */
+    SkPDF::EncodeJpegCallback jpegEncoder = nullptr;
+
+    // Skia's PDF support depends on having both a jpeg encoder and decoder for writing
+    // compact PDFs. It will technically work, but produce larger than optimal PDFs
+    // if either the decoder or encoder are left as nullptr. If clients will be creating
+    // PDFs that don't use images or otherwise want to incur this cost (with the upside
+    // of not having a jpeg library), they should set this to true to avoid an internal
+    // assert from firing.
+    bool allowNoJpegs = false;
+};
+
+namespace NodeID {
+static const constexpr int Nothing = 0;
+static const constexpr int OtherArtifact = -1;
+static const constexpr int PaginationArtifact = -2;
+static const constexpr int PaginationHeaderArtifact = -3;
+static const constexpr int PaginationFooterArtifact = -4;
+static const constexpr int PaginationWatermarkArtifact = -5;
+static const constexpr int LayoutArtifact = -6;
+static const constexpr int PageArtifact = -7;
+static const constexpr int BackgroundArtifact = -8;
+}  // namespace NodeID
+
+/** Associate a node ID with subsequent drawing commands in an
+    SkCanvas.  The same node ID can appear in a StructureElementNode
+    in order to associate a document's structure element tree with
+    its content.
+
+    A node ID of zero indicates no node ID. Negative node IDs are reserved.
+
+    @param canvas  The canvas used to draw to the PDF.
+    @param nodeId  The node ID for subsequent drawing commands.
+*/
+SK_API void SetNodeId(SkCanvas* dst, int nodeID);
+
+/** Create a PDF-backed document, writing the results into a SkWStream.
+
+    PDF pages are sized in point units. 1 pt == 1/72 inch == 127/360 mm.
+
+    @param stream A PDF document will be written to this stream.  The document may write
+           to the stream at anytime during its lifetime, until either close() is
+           called or the document is deleted.
+    @param metadata a PDFmetadata object. Some fields may be left empty.
+
+    @returns NULL if there is an error, otherwise a newly created PDF-backed SkDocument.
+*/
+SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream, const Metadata& metadata);
+
+#if !defined(SK_DISABLE_LEGACY_PDF_JPEG)
+static inline sk_sp<SkDocument> MakeDocument(SkWStream* stream) {
+    return MakeDocument(stream, Metadata());
+}
+#endif
+
+}  // namespace SkPDF
+
+#endif  // SkPDFDocument_DEFINED