@shopify/react-native-skia 2.0.0-next.3 → 2.0.0-next.5

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

@@ -16,9 +16,12 @@
 #include <vector>
 
 class SkCanvas;
+class SkCodec;
+class SkData;
 class SkExecutor;
 class SkPDFArray;
 class SkPDFStructTree;
+class SkPixmap;
 class SkWStream;
 
 #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
@@ -80,6 +83,9 @@ struct DateTime {
     void toISO8601(SkString* dst) const;
 };
 
+using DecodeJpegCallback = std::unique_ptr<SkCodec> (*)(sk_sp<SkData>);
+using EncodeJpegCallback = bool (*)(SkWStream* dst, const SkPixmap& src, int quality);
+
 /** Optional metadata to be passed into the PDF factory function.
 */
 struct Metadata {
@@ -157,6 +163,7 @@ struct Metadata {
     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,
@@ -186,14 +193,50 @@ struct Metadata {
     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.
+    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.
@@ -207,15 +250,17 @@ SK_API void SetNodeId(SkCanvas* dst, int nodeID);
     @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.  Any fields may be left empty.
+    @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
 

package/cpp/skia/include/docs/SkPDFJpegHelpers.h

@@ -0,0 +1,41 @@
+/*
+ * 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 SkPDFJPEGHelpers_DEFINED
+#define SkPDFJPEGHelpers_DEFINED
+
+#include "include/codec/SkJpegDecoder.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/docs/SkPDFDocument.h"
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+
+#include <memory>
+
+namespace SkPDF::JPEG {
+inline std::unique_ptr<SkCodec> Decode(sk_sp<SkData> data) {
+    return SkJpegDecoder::Decode(data, nullptr, nullptr);
+}
+
+inline bool Encode(SkWStream* dst, const SkPixmap& src, int quality) {
+    SkJpegEncoder::Options jOpts;
+    jOpts.fQuality = quality;
+    return SkJpegEncoder::Encode(dst, src, jOpts);
+}
+
+inline SkPDF::Metadata MetadataWithCallbacks() {
+    SkPDF::Metadata m;
+    m.jpegDecoder = SkPDF::JPEG::Decode;
+    m.jpegEncoder = SkPDF::JPEG::Encode;
+    return m;
+}
+
+}  // namespace SkPDF::JPEG
+
+#endif

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -126,6 +126,8 @@ public:
         // don't run the inliner directly, but they still get an inlining pass once they are
         // painted.)
         bool forceUnoptimized = false;
+        // When possible this name will be used to identify the created runtime effect.
+        std::string_view fName;
 
     private:
         friend class SkRuntimeEffect;
@@ -317,7 +319,9 @@ private:
     friend class SkRuntimeEffectPriv;
 
     uint32_t fHash;
-    uint32_t fStableKey;
+    // When not 0, this field holds a StableKey value or a user-defined stable key
+    uint32_t fStableKey = 0;
+    SkString fName;
 
     std::unique_ptr<SkSL::Program> fBaseProgram;
     std::unique_ptr<SkSL::RP::Program> fRPProgram;

package/cpp/skia/include/effects/SkTableMaskFilter.h

@@ -38,6 +38,10 @@ public:
     static SkMaskFilter* CreateClip(uint8_t min, uint8_t max);
 
     SkTableMaskFilter() = delete;
+
+private:
+    static void RegisterFlattenables();
+    friend class SkFlattenable;
 };
 
 #endif

package/cpp/skia/include/gpu/graphite/BackendTexture.h

@@ -17,7 +17,6 @@
 namespace skgpu::graphite {
 
 class BackendTextureData;
-struct VulkanTextureInfo;
 
 class SK_API BackendTexture {
 public:
@@ -61,4 +60,3 @@ private:
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_BackendTexture_DEFINED
-

package/cpp/skia/include/gpu/graphite/ContextOptions.h

@@ -9,12 +9,14 @@
 #define skgpu_graphite_ContextOptions_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
 #include <optional>
 
 class SkData;
+class SkRuntimeEffect;
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -136,6 +138,21 @@ struct SK_API ContextOptions {
     PipelineCallbackContext fPipelineCallbackContext = nullptr;
     PipelineCallback fPipelineCallback = nullptr;
 
+    /**
+     * The runtime effects provided here will be registered as user-defined *known* runtime
+     * effects and will be given a stable key. Such runtime effects can then be used in
+     * serialized pipeline keys (c.f. PrecompileContext::precompile).
+     *
+     * Graphite will take a ref on the provided runtime effects and they will persist for as long
+     * as the Context exists. Rather than recreating new SkRuntimeEffects using the same SkSL,
+     * clients should use the existing SkRuntimeEffects provided here.
+     *
+     * Warning: Registering runtime effects here does obligate users to clear out their caches
+     * of serialized pipeline keys if the provided runtime effects ever change in a meaningful way.
+     * This includes adding, removing or reordering the effects provided here.
+     */
+    SkSpan<sk_sp<SkRuntimeEffect>> fUserDefinedKnownRuntimeEffects;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

package/cpp/skia/include/gpu/graphite/GraphiteTypes.h

@@ -140,44 +140,47 @@ enum class DepthStencilFlags : int {
  */
 enum DrawTypeFlags : uint16_t {
 
-    kNone             = 0b000000000,
+    kNone             = 0,
 
     // kBitmapText_Mask should be used for the BitmapTextRenderStep[mask] RenderStep
-    kBitmapText_Mask  = 0b00000001,
+    kBitmapText_Mask  = 1 << 0,
     // kBitmapText_LCD should be used for the BitmapTextRenderStep[LCD] RenderStep
-    kBitmapText_LCD   = 0b00000010,
+    kBitmapText_LCD   = 1 << 1,
     // kBitmapText_Color should be used for the BitmapTextRenderStep[color] RenderStep
-    kBitmapText_Color = 0b00000100,
+    kBitmapText_Color = 1 << 2,
     // kSDFText should be used for the SDFTextRenderStep RenderStep
-    kSDFText          = 0b00001000,
+    kSDFText          = 1 << 3,
     // kSDFText_LCD should be used for the SDFTextLCDRenderStep RenderStep
-    kSDFText_LCD      = 0b00010000,
+    kSDFText_LCD      = 1 << 4,
 
     // kDrawVertices should be used to generate Pipelines that use the following RenderSteps:
     //    VerticesRenderStep[*] for:
-    //        [tris], [tris-texCoords], [tris-color], [tris-color-texCoords],
-    //        [tristrips], [tristrips-texCoords], [tristrips-color], [tristrips-color-texCoords]
-    kDrawVertices     = 0b00100000,
+    //        [Tris], [TrisTexCoords], [TrisColor], [TrisColorTexCoords],
+    //        [Tristrips], [TristripsTexCoords], [TristripsColor], [TristripsColorTexCoords]
+    kDrawVertices     = 1 << 5,
+
+    // kCircularArc renders filled circular arcs, with or without the center included, and
+    // stroked circular arcs with butt or round caps that don't include the center point.
+    // It corresponds to the CircularArcRenderStep.
+    kCircularArc      = 1 << 6,
 
     // kSimpleShape should be used to generate Pipelines that use the following RenderSteps:
-    //    AnalyticBlurRenderStep
     //    AnalyticRRectRenderStep
     //    PerEdgeAAQuadRenderStep
-    //    CoverBoundsRenderStep[non-aa-fill]
-    kSimpleShape      = 0b01000000,
+    //    CoverBoundsRenderStep[NonAAFill]
+    kSimpleShape      = 1 << 7,
 
     // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps:
     //    CoverageMaskRenderStep
-    //    CoverBoundsRenderStep[*] for [inverse-cover], [regular-cover]
+    //    CoverBoundsRenderStep[*] for [InverseCover], [RegularCover]
     //    TessellateStrokeRenderStep
-    //    TessellateWedgesRenderStep[*] for [convex], [evenodd], [winding]
-    //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
-    //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
-    kNonSimpleShape   = 0b10000000,
+    //    TessellateWedgesRenderStep[*] for [Convex], [EvenOdd], [Winding]
+    //    TessellateCurvesRenderStep[*] for [EvenOdd], [Winding]
+    //    MiddleOutFanRenderStep[*] for [EvenOdd], [Winding]
+    kNonSimpleShape   = 1 << 8,
 
     kLast = kNonSimpleShape,
 };
-static constexpr int kDrawTypeFlagsCnt = static_cast<int>(DrawTypeFlags::kLast) + 1;
 
 } // namespace skgpu::graphite
 

package/cpp/skia/include/gpu/graphite/PrecompileContext.h

@@ -14,6 +14,8 @@
 #include <chrono>
 #include <memory>
 
+class SkData;
+
 namespace skgpu::graphite {
 
 class SharedContext;
@@ -32,6 +34,28 @@ public:
      */
     void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Pipeline usage.
+     */
+    void reportPipelineStats();
+
+    /**
+     * Precompile one specific Pipeline that has been previously serialized. Serialized pipeline
+     * keys can be acquired via the ContextOptions::PipelineCallback.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        true if a Pipeline was created from the key; false otherwise
+     */
+    bool precompile(sk_sp<SkData> serializedPipelineKey);
+
+    /**
+     * Get a human-readable version of a serialized pipeline key.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        A human-readable version of the provided key; "" on failure.
+     */
+    std::string getPipelineLabel(sk_sp<SkData> serializedPipelineKey);
+
     // Provides access to functions that aren't part of the public API.
     PrecompileContextPriv priv();
     const PrecompileContextPriv priv() const;  // NOLINT(readability-const-return-type)

package/cpp/skia/include/gpu/graphite/TextureInfo.h

@@ -18,70 +18,115 @@ struct SkISize;
 
 namespace skgpu::graphite {
 
-class TextureInfoData;
+enum class TextureFormat : uint8_t;
 
+/**
+ * TextureInfo is a backend-agnostic wrapper around the properties of a texture, sans dimensions.
+ * It is designed this way to be compilable w/o bringing in a specific backend's build files, and
+ * without requiring heap allocations of virtual types.
+ */
 class SK_API TextureInfo {
+private:
+    class Data;
+    friend class MtlTextureInfo;
+    friend class DawnTextureInfo;
+    friend class VulkanTextureInfo;
+
+    // Size is the largest of the Data subclasses assuming a 64-bit compiler.
+    inline constexpr static size_t kMaxSubclassSize = 112;
+    using AnyTextureInfoData = SkAnySubclass<Data, kMaxSubclassSize>;
+
+    // Base properties for all backend-specific properties. Clients managing textures directly
+    // should use the public subclasses of Data directly, e.g. MtlTextureInfo/DawnTextureInfo.
+    //
+    // Each backend subclass must expose to TextureInfo[Priv]:
+    //   static constexpr BackendApi kBackend;
+    //   Protected isProtected() const;
+    //   TextureFormat viewFormat() const;
+    //   bool serialize(SkWStream*) const;
+    //   bool deserialize(SkStream*);
+    class Data {
+    public:
+        virtual ~Data() = default;
+
+        Data(uint32_t sampleCount, skgpu::Mipmapped mipmapped)
+                : fSampleCount(sampleCount)
+                , fMipmapped(mipmapped) {}
+
+        Data() = default;
+        Data(const Data&) = default;
+
+        Data& operator=(const Data&) = default;
+
+        // NOTE: These fields are accessible via the backend-specific subclasses.
+        uint32_t fSampleCount = 1;
+        Mipmapped fMipmapped = Mipmapped::kNo;
+
+    private:
+        friend class TextureInfo;
+        friend class TextureInfoPriv;
+
+        virtual SkString toBackendString() const = 0;
+
+        virtual void copyTo(AnyTextureInfoData&) const = 0;
+        // Passed in TextureInfo will have data of the same backend type and subclass, and
+        // base properties of Data have already been checked for equality/compatibility.
+        virtual bool isCompatible(const TextureInfo& that, bool requireExact) const = 0;
+    };
+
 public:
-    TextureInfo();
-    ~TextureInfo();
+    TextureInfo() = default;
+    ~TextureInfo() = default;
+
     TextureInfo(const TextureInfo&);
     TextureInfo& operator=(const TextureInfo&);
 
-    bool operator==(const TextureInfo&) const;
+    bool operator==(const TextureInfo& that) const {
+        return this->isCompatible(that, /*requireExact=*/true);
+    }
     bool operator!=(const TextureInfo& that) const { return !(*this == that); }
 
-    bool isValid() const { return fValid; }
-    BackendApi backend() const { return fBackend; }
+    bool isValid() const { return fData.has_value(); }
+    BackendApi backend() const {
+        SkASSERT(fData.has_value() || fBackend == BackendApi::kUnsupported);
+        return fBackend;
+    }
 
-    uint32_t numSamples() const { return fSampleCount; }
-    Mipmapped mipmapped() const { return fMipmapped; }
+    uint32_t numSamples() const { return fData.has_value() ? fData->fSampleCount : 1; }
+    Mipmapped mipmapped() const { return fData.has_value() ? fData->fMipmapped   : Mipmapped::kNo; }
     Protected isProtected() const { return fProtected; }
-    SkTextureCompressionType compressionType() const;
-    bool isMemoryless() const;
 
-    bool isCompatible(const TextureInfo& that) const;
+    // Return true if `that` describes a texture that is compatible with this info and can validly
+    // be used to fulfill a promise image that was created with this TextureInfo.
+    bool canBeFulfilledBy(const TextureInfo& that) const {
+        return this->isCompatible(that, /*requireExact=*/false);
+    }
+
     // Return a string containing the full description of this TextureInfo.
     SkString toString() const;
-    // Return a string containing only the info relevant for its use as a RenderPass attachment.
-    SkString toRPAttachmentString() const;
 
 private:
-    friend class TextureInfoData;
     friend class TextureInfoPriv;
 
-    // Size determined by looking at the TextureInfoData subclasses, then guessing-and-checking.
-    // Compiler will complain if this is too small - in that case, just increase the number.
-    inline constexpr static size_t kMaxSubclassSize = 112;
-    using AnyTextureInfoData = SkAnySubclass<TextureInfoData, kMaxSubclassSize>;
-
-    template <typename SomeTextureInfoData>
-    TextureInfo(BackendApi backend,
-                uint32_t sampleCount,
-                skgpu::Mipmapped mipped,
-                skgpu::Protected isProtected,
-                const SomeTextureInfoData& textureInfoData)
-            : fBackend(backend)
-            , fValid(true)
-            , fSampleCount(sampleCount)
-            , fMipmapped(mipped)
-            , fProtected(isProtected) {
-        fTextureInfoData.emplace<SomeTextureInfoData>(textureInfoData);
+    template <typename BackendTextureData,
+              std::enable_if_t<std::is_base_of_v<Data, BackendTextureData>, bool> = true>
+    explicit TextureInfo(const BackendTextureData& data)
+            : fBackend(BackendTextureData::kBackend)
+            , fViewFormat(data.viewFormat())
+            , fProtected(data.isProtected()) {
+        fData.emplace<BackendTextureData>(data);
     }
 
-    friend size_t ComputeSize(SkISize dimensions, const TextureInfo&);  // for bytesPerPixel
-
-    size_t bytesPerPixel() const;
+    bool isCompatible(const TextureInfo& that, bool requireExact) const;
 
-    BackendApi fBackend = BackendApi::kMock;
-    bool fValid = false;
+    skgpu::BackendApi  fBackend = BackendApi::kUnsupported;
+    AnyTextureInfoData fData;
 
-    uint32_t fSampleCount = 1;
-    Mipmapped fMipmapped = Mipmapped::kNo;
+    // Derived properties from the backend data, cached to avoid a virtual function call
+    TextureFormat fViewFormat;
     Protected fProtected = Protected::kNo;
-
-    AnyTextureInfoData fTextureInfoData;
 };
 
-}  // namespace skgpu::graphite
+} // namespace skgpu::graphite
 
-#endif  //skgpu_graphite_TextureInfo_DEFINED
+#endif // skgpu_graphite_TextureInfo_DEFINED

package/cpp/skia/include/gpu/graphite/YUVABackendTextures.h

@@ -37,10 +37,15 @@ public:
      * by Mipmapped. This will produce an invalid result (return false from isValid()) if the
      * passed formats' channels don't agree with SkYUVAInfo.
      */
-    YUVABackendTextureInfo(const Recorder*,
-                           const SkYUVAInfo&,
+    YUVABackendTextureInfo(const SkYUVAInfo&,
                            SkSpan<const TextureInfo>,
                            Mipmapped);
+    // DEPRECATED: No more need for a Recorder to construct YUVABackendTextureInfo
+    YUVABackendTextureInfo(Recorder*,
+                           const SkYUVAInfo& yuvaInfo,
+                           SkSpan<const TextureInfo> textures,
+                           Mipmapped mipmapped)
+            : YUVABackendTextureInfo(yuvaInfo, textures, mipmapped) {}
 
     bool operator==(const YUVABackendTextureInfo&) const;
     bool operator!=(const YUVABackendTextureInfo& that) const { return !(*this == that); }
@@ -95,9 +100,13 @@ public:
      * indicated by the SkYUVAInfo. This will produce an invalid result (return false from
      * isValid()) if the passed texture formats' channels don't agree with SkYUVAInfo.
      */
-    YUVABackendTextures(const Recorder*,
-                        const SkYUVAInfo&,
+    YUVABackendTextures(const SkYUVAInfo&,
                         SkSpan<const BackendTexture>);
+    // DEPRECATED: No more need for a Recorder to construct YUVABackendTextureInfo
+    YUVABackendTextures(Recorder*,
+                        const SkYUVAInfo& yuvaInfo,
+                        SkSpan<const BackendTexture> textures)
+            : YUVABackendTextures(yuvaInfo, textures) {}
 
     SkSpan<const BackendTexture> planeTextures() const {
         return SkSpan<const BackendTexture>(fPlaneTextures);

package/cpp/skia/include/gpu/graphite/dawn/DawnBackendContext.h

@@ -11,8 +11,13 @@
 #include "include/core/SkTypes.h"
 #include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
+#include <memory>
+
 namespace skgpu::graphite {
 
+class Context;
+struct ContextOptions;
+
 /**
  * WebGPU needs to allow the main thread loop to run to detect GPU progress. Dawn native has a
  * function wgpu::Instance::ProcessEvents, not (currently) present in WebGPU, that can be used to
@@ -63,6 +68,10 @@ struct SK_API DawnBackendContext {
 #endif
 };
 
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeDawn(const DawnBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_DawnBackendContext_DEFINED