@shopify/react-native-skia 2.0.5 → 2.0.6

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

@@ -10,36 +10,52 @@
 
 #include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkShader.h"
-#include "include/gpu/graphite/ContextOptions.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/Recorder.h"
+#include "include/gpu/graphite/Recorder.h"  // IWYU pragma: keep
 #include "include/private/base/SingleOwner.h"
+#include "include/private/base/SkThreadAnnotations.h"
 
 #if defined(GPU_TEST_UTILS)
 #include "include/private/base/SkMutex.h"
 #endif
 
 #include <chrono>
+#include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <memory>
+#include <vector>
 
+class SkColorInfo;
+class SkSurface;
+enum SkYUVColorSpace : int;
 class SkColorSpace;
-class SkRuntimeEffect;
 class SkTraceMemoryDump;
+struct SkIRect;
+struct SkImageInfo;
+
+namespace skcpu {
+class ContextImpl;
+class Recorder;
+}  // namespace skcpu
+
+namespace skgpu {
+enum class BackendApi : unsigned int;
+enum class GpuStatsFlags : uint32_t;
+}
 
 namespace skgpu::graphite {
 
 class BackendTexture;
 class Buffer;
 class ClientMappedBufferManager;
-class Context;
 class ContextPriv;
-class GlobalCache;
-class PaintOptions;
+struct ContextOptions;
 class PrecompileContext;
 class QueueManager;
-class Recording;
 class ResourceProvider;
 class SharedContext;
 class TextureProxy;
@@ -56,6 +72,7 @@ public:
     BackendApi backend() const;
 
     std::unique_ptr<Recorder> makeRecorder(const RecorderOptions& = {});
+    std::unique_ptr<skcpu::Recorder> makeCPURecorder();
 
     /** Creates a helper object that can be moved to a different thread and used
      *  for precompilation.
@@ -291,6 +308,12 @@ private:
     friend class ContextCtorAccessor;
 
     struct PixelTransferResult {
+        PixelTransferResult();
+        PixelTransferResult(const PixelTransferResult&);
+        PixelTransferResult(PixelTransferResult&&);
+        PixelTransferResult& operator=(const PixelTransferResult&);
+        ~PixelTransferResult();
+
         using ConversionFn = void(void* dst, const void* mappedBuffer);
         // If null then the transfer could not be performed. Otherwise this buffer will contain
         // the pixel data when the transfer is complete.
@@ -357,6 +380,7 @@ private:
     std::unique_ptr<ResourceProvider> fResourceProvider;
     std::unique_ptr<QueueManager> fQueueManager;
     std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
+    std::unique_ptr<const skcpu::ContextImpl> fCPUContext;
 
     // In debug builds we guard against improper thread handling. This guard is passed to the
     // ResourceCache for the Context.

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

@@ -9,6 +9,7 @@
 #define skgpu_graphite_ContextOptions_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
 #include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
@@ -45,7 +46,16 @@ struct SK_API ContextOptions {
      *
      * If <= 1, Graphite will disable internal code paths that use multisampling.
      */
-    int fInternalMultisampleCount = 4;
+    uint8_t fInternalMultisampleCount = 4;
+
+    /**
+     * If set, this specifies the max width/height of MSAA textures that Graphite should use for
+     * internal draws. Graphite might have to break the drawing region into multiple tiles to
+     * satisfy the size constraint.
+     * Note: this option will be ignored if the backend doesn't support it, or if a more optimal HW
+     * feature is available.
+     */
+    std::optional<SkISize> fInternalMSAATileSize = std::nullopt;
 
     /**
      * Will the client make sure to only ever be executing one thread that uses the Context and all
@@ -89,10 +99,18 @@ struct SK_API ContextOptions {
     bool fSupportBilerpFromGlyphAtlas = false;
 
     /**
-     * For the moment, if Recordings are replayed in the order they are recorded, then
-     * Graphite can make certain assumptions that allow for better performance. Otherwise
-     * we have to flush some caches at the start of each Recording to ensure that they can
+     * For the moment, if Recordings from the same Recorder are replayed in the order they are
+     * recorded, then Graphite can make certain assumptions that allow for better performance.
+     * Otherwise we have to flush some caches at the start of each Recording to ensure that they can
      * be played back properly.
+     *
+     * This is the default ordering requirement for a Recorder. It can be overridden by
+     * setting the same field on the RecorderOptions passed to makeRecorder.
+     *
+     * Regardless of this value or a per-Recorder's setting, Recordings from separate Recorders can
+     * always be inserted in any order but it is the application's responsible to ensure that any
+     * implicit dependencies between the Recorders are respected (e.g. rendering to an SkSurface
+     * in one Recorder and sampling from that SkSurface's SkImage view on another Recorder).
      */
     bool fRequireOrderedRecordings = false;
 

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

@@ -168,7 +168,11 @@ enum DrawTypeFlags : uint16_t {
     //    AnalyticRRectRenderStep
     //    PerEdgeAAQuadRenderStep
     //    CoverBoundsRenderStep[NonAAFill]
-    kSimpleShape      = 1 << 7,
+    kAnalyticRRect    = 1 << 7,
+    kPerEdgeAAQuad    = 1 << 8,
+    kNonAAFillRect    = 1 << 9,
+
+    kSimpleShape      = kAnalyticRRect | kPerEdgeAAQuad | kNonAAFillRect,
 
     // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps:
     //    CoverageMaskRenderStep
@@ -177,9 +181,22 @@ enum DrawTypeFlags : uint16_t {
     //    TessellateWedgesRenderStep[*] for [Convex], [EvenOdd], [Winding]
     //    TessellateCurvesRenderStep[*] for [EvenOdd], [Winding]
     //    MiddleOutFanRenderStep[*] for [EvenOdd], [Winding]
-    kNonSimpleShape   = 1 << 8,
-
-    kLast = kNonSimpleShape,
+    kNonSimpleShape   = 1 << 10,
+
+    // This draw type covers all the methods Skia uses to draw drop shadows. It can be used to
+    // generate Pipelines which, as part of their labels, have:
+    //     the AnalyticBlurRenderStep
+    //     VerticesRenderStep[TrisColor] with a GaussianColorFilter
+    // For this draw type the PaintOptions parameter to Precompile() will be ignored.
+    kDropShadows      = 1 << 11,
+
+    // kAnalyticClip should be combined with the primary drawType for Pipelines that contain
+    // either of the following sub-strings:
+    //    AnalyticClip
+    //    AnalyticAndAtlasClip
+    kAnalyticClip     = 1 << 12,
+
+    kLast = kAnalyticClip,
 };
 
 } // namespace skgpu::graphite

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

@@ -10,9 +10,11 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SingleOwner.h"
+#include "include/private/base/SkAPI.h"
 
 #include <chrono>
 #include <memory>
+#include <string>
 
 class SkData;
 
@@ -34,10 +36,22 @@ public:
      */
     void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
 
+    enum class StatOptions {
+        // Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Precompiled Pipeline
+        // usage:
+        //    Skia.Graphite.Precompile.NormalPreemptedByPrecompile
+        //    Skia.Graphite.Precompile.UnpreemptedPrecompilePipelines
+        //    Skia.Graphite.Precompile.UnusedPrecompiledPipelines
+        kPrecompile,
+        // Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Pipeline cache usage:
+        //    Skia.Graphite.PipelineCache.PipelineUsesInEpoch
+        kPipelineCache,
+    };
+
     /**
-     * Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Pipeline usage.
+     * Emit histograms histograms related to Skia's Pipelines (c.f. the StatOptions enum).
      */
-    void reportPipelineStats();
+    void reportPipelineStats(StatOptions option = StatOptions::kPrecompile);
 
     /**
      * Precompile one specific Pipeline that has been previously serialized. Serialized pipeline

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

@@ -8,22 +8,33 @@
 #ifndef skgpu_graphite_Recorder_DEFINED
 #define skgpu_graphite_Recorder_DEFINED
 
+#include "include/core/SkCPURecorder.h"
+#include "include/core/SkRecorder.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkSize.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/gpu/graphite/Recording.h"
 #include "include/private/base/SingleOwner.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkTArray.h"
 
 #include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
 
-struct AHardwareBuffer;
 class SkCanvas;
-struct SkImageInfo;
 class SkPixmap;
 class SkTraceMemoryDump;
+struct SkISize;
+struct SkImageInfo;
+
+#if defined(SK_BUILD_FOR_ANDROID)
+struct AHardwareBuffer;
+#endif
 
 namespace skgpu {
+enum class BackendApi : unsigned int;
 class RefCntedCallback;
 class TokenTracker;
 }
@@ -37,26 +48,23 @@ namespace skgpu::graphite {
 
 class AtlasProvider;
 class BackendTexture;
-class Caps;
 class Context;
 class Device;
 class DrawBufferManager;
-class GlobalCache;
 class ImageProvider;
-class ProxyCache;
 class ProxyReadCountMap;
 class RecorderPriv;
 class ResourceProvider;
 class RuntimeEffectDictionary;
 class SharedContext;
-class Task;
 class TaskList;
 class TextureDataBlock;
 class TextureInfo;
-class UniformDataBlock;
 class UploadBufferManager;
 class UploadList;
 
+struct RecorderOptionsPriv;
+
 template<typename T> class PipelineDataCache;
 using TextureDataCache = PipelineDataCache<TextureDataBlock>;
 
@@ -70,19 +78,29 @@ struct SK_API RecorderOptions final {
     static constexpr size_t kDefaultRecorderBudget = 256 * (1 << 20);
     // What is the budget for GPU resources allocated and held by this Recorder.
     size_t fGpuBudgetInBytes = kDefaultRecorderBudget;
+    // If Recordings are known to be played back in the order they are recorded, then Graphite
+    // may be able to make certain assumptions that improve performance. This is often the case
+    // if the content being drawn triggers the use of internal atlasing in Graphite (e.g. text).
+    std::optional<bool> fRequireOrderedRecordings;
+
+    // Private options that are only meant for testing within Skia's tools.
+    RecorderOptionsPriv* fRecorderOptionsPriv = nullptr;
 };
 
-class SK_API Recorder final {
+class SK_API Recorder final : public SkRecorder {
 public:
     Recorder(const Recorder&) = delete;
     Recorder(Recorder&&) = delete;
     Recorder& operator=(const Recorder&) = delete;
     Recorder& operator=(Recorder&&) = delete;
 
-    ~Recorder();
+    ~Recorder() override;
 
     BackendApi backend() const;
 
+    Type type() const override { return SkRecorder::Type::kGraphite; }
+    skcpu::Recorder* cpuRecorder() override;
+
     std::unique_ptr<Recording> snap();
 
     ImageProvider* clientImageProvider() { return fClientImageProvider.get(); }
@@ -281,6 +299,8 @@ private:
 
     uint32_t fUniqueID;  // Needed for MessageBox handling for text
     uint32_t fNextRecordingID = 1;
+    const bool fRequireOrderedRecordings;
+
     std::unique_ptr<AtlasProvider> fAtlasProvider;
     std::unique_ptr<TokenTracker> fTokenTracker;
     std::unique_ptr<sktext::gpu::StrikeCache> fStrikeCache;

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

@@ -9,13 +9,16 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkSize.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkTArray.h"
-
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <unordered_set>
 #include <vector>
 
+struct SkISize;
+
 namespace skgpu {
 class RefCntedCallback;
 }
@@ -47,6 +50,7 @@ private:
     class LazyProxyData {
     public:
         LazyProxyData(const Caps*, SkISize dimensions, const TextureInfo&);
+        ~LazyProxyData();
 
         TextureProxy* lazyProxy();
         sk_sp<TextureProxy> refLazyProxy();
@@ -72,7 +76,7 @@ private:
     bool addCommands(CommandBuffer*, ResourceProvider*);
     void addResourceRef(sk_sp<Resource>);
 
-    // Used to verify ordering
+    // Used to verify ordering if recorder ID is not SK_InvalidGenID
     uint32_t fUniqueID;
     uint32_t fRecorderID;
 

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

@@ -49,7 +49,7 @@ private:
     public:
         virtual ~Data() = default;
 
-        Data(uint32_t sampleCount, skgpu::Mipmapped mipmapped)
+        Data(uint8_t sampleCount, skgpu::Mipmapped mipmapped)
                 : fSampleCount(sampleCount)
                 , fMipmapped(mipmapped) {}
 
@@ -59,7 +59,7 @@ private:
         Data& operator=(const Data&) = default;
 
         // NOTE: These fields are accessible via the backend-specific subclasses.
-        uint32_t fSampleCount = 1;
+        uint8_t fSampleCount = 1;
         Mipmapped fMipmapped = Mipmapped::kNo;
 
     private:
@@ -92,7 +92,7 @@ public:
         return fBackend;
     }
 
-    uint32_t numSamples() const { return fData.has_value() ? fData->fSampleCount : 1; }
+    uint8_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; }
 

package/cpp/skia/include/gpu/graphite/precompile/PaintOptions.h

@@ -27,6 +27,7 @@ class PrecompileShader;
 enum class Coverage;
 enum DrawTypeFlags : uint16_t;
 enum class PrecompileImageFilterFlags : uint32_t;
+enum class TextureFormat : uint8_t;
 
 class KeyContext;
 class PaintOptionsPriv;
@@ -139,6 +140,11 @@ public:
     void setDither(bool dither) { fDither = dither; }
     bool isDither() const { return fDither; }
 
+    void setPaintColorIsOpaque(bool paintColorIsOpaque) {
+        fPaintColorIsOpaque = paintColorIsOpaque;
+    }
+    bool isPaintColorOpaque() const { return fPaintColorIsOpaque; }
+
     // Provides access to functions that aren't part of the public API.
     PaintOptionsPriv priv();
     const PaintOptionsPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -155,6 +161,10 @@ private:
 
     void setClipShaders(SkSpan<const sk_sp<PrecompileShader>> clipShaders);
 
+    // In the main API this is specified via the SkBlender parameter to drawVertices
+    void setPrimitiveBlendMode(SkBlendMode bm) { fPrimitiveBlendMode = bm; }
+    void setSkipColorXform(bool skipColorXform) { fSkipColorXform = skipColorXform; }
+
     int numShaderCombinations() const;
     int numColorFilterCombinations() const;
     int numBlendCombinations() const;
@@ -163,10 +173,12 @@ private:
     int numCombinations() const;
     // 'desiredCombination' must be less than the result of the numCombinations call
     void createKey(const KeyContext&,
+                   TextureFormat,
                    PaintParamsKeyBuilder*,
                    PipelineDataGatherer*,
                    int desiredCombination,
                    bool addPrimitiveBlender,
+                   bool addAnalyticClip,
                    Coverage coverage) const;
 
     typedef std::function<void(UniquePaintParamsID id,
@@ -192,7 +204,10 @@ private:
     skia_private::TArray<sk_sp<PrecompileImageFilter>> fImageFilterOptions;
     skia_private::TArray<sk_sp<PrecompileMaskFilter>> fMaskFilterOptions;
 
+    SkBlendMode fPrimitiveBlendMode = SkBlendMode::kSrcOver;
+    bool fSkipColorXform = false;
     bool fDither = false;
+    bool fPaintColorIsOpaque = true;
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/precompile/PrecompileShader.h

@@ -106,37 +106,113 @@ namespace PrecompileShaders {
                                          SkSpan<const sk_sp<PrecompileShader>> srcs);
     SK_API sk_sp<PrecompileShader> CoordClamp(SkSpan<const sk_sp<PrecompileShader>>);
 
-    // In the main Skia API ImageShaders are usually created via a SkImage::makeShader call.
-    // Since the SkImage used to create the ImageShader is unlikely to be present at precompilation
-    // time this entry point allows the equivalent precompilation program structure to be created.
-    // Note that this factory is for non-YUV SkImages, the YUVImage factory (below) should be used
-    // to represent the shading and sampling required for YUV images.
-    SK_API sk_sp<PrecompileShader> Image(SkSpan<const SkColorInfo> = {},
-                                         SkSpan<const SkTileMode> = {});
+    enum class ImageShaderFlags : uint16_t {
+        kNone                 = 0,
+
+        kCubicSampling        = 1 << 1,
+        kIncludeAlphaOnly     = 1 << 2,
+
+        kAll = kCubicSampling | kIncludeAlphaOnly,
+        kExcludeCubic = kIncludeAlphaOnly,
+        kNoAlphaNoCubic = kNone,
+    };
+
+    static constexpr SkTileMode kAllTileModes[] = {
+        SkTileMode::kClamp,
+        SkTileMode::kRepeat,
+        SkTileMode::kMirror,
+        SkTileMode::kDecal,
+    };
+
+    /**
+        In the main Skia API ImageShaders are usually created via a SkImage::makeShader call.
+        Since the SkImage used to create the ImageShader is unlikely to be present at precompilation
+        time this entry point allows the equivalent precompilation program structure to be created.
+        Note that this factory is for non-YUV SkImages, the YUVImage factory (below) should be used
+        to represent the shading and sampling required for YUV images.
+
+        @param shaderFlags Specify the sampling variations that will be precompiled.
+        @param colorInfos a span of SkColorInfos to narrow down the combinations.
+                          In general, the color info affects the swizzle and colorSpace
+                          transformation of the final Pipeline.
+        @param tileModes a span of SkTileModes to narrow down the combinations.
+                         The default will generate all possible combinations. Passing an
+                         empty SkSpan will eliminate the Shader-based sampling combinations.
+        @return A precompile shader capturing the specified combinations
+    */
+    SK_API sk_sp<PrecompileShader> Image(ImageShaderFlags = ImageShaderFlags::kAll,
+                                         SkSpan<const SkColorInfo> = {},
+                                         SkSpan<const SkTileMode> = { kAllTileModes });
+
+    /** DEPRECATED
+     *  Use above version.
+     */
+    SK_API sk_sp<PrecompileShader> Image(SkSpan<const SkColorInfo> colorInfos,
+                                         SkSpan<const SkTileMode> = { kAllTileModes });
+
     // As with the above Image call, raw ImageShaders are usually created via an
     // SkImage::makeRawShader call. The RawImage call allows the equivalent precompilation
     // program structure to be created without needing the SkImage.
-    SK_API sk_sp<PrecompileShader> RawImage(SkSpan<const SkColorInfo> = {},
-                                            SkSpan<const SkTileMode> = {});
+    SK_API sk_sp<PrecompileShader> RawImage(ImageShaderFlags = ImageShaderFlags::kExcludeCubic,
+                                            SkSpan<const SkColorInfo> = {},
+                                            SkSpan<const SkTileMode> = { kAllTileModes });
 
-    // In the main Skia API, the specifics of the SkImage used for the SkImage::makeShader call
-    // can determine whether normal or YUV sampling is required. This entry point allows clients
-    // to specify that the future image will be a YUV image.
-    SK_API sk_sp<PrecompileShader> YUVImage();
+    enum class YUVImageShaderFlags : uint16_t {
+        kNone                       = 0,
+
+        kHardwareSamplingNoSwizzle  = 1 << 1,
+        kHardwareSampling           = 1 << 2,
+        kShaderBasedSampling        = 1 << 3,
+        kCubicSampling              = 1 << 4,
+
+        kExcludeCubic = kHardwareSamplingNoSwizzle | kHardwareSampling | kShaderBasedSampling,
+        kNoCubicNoNonSwizzledHW = kHardwareSamplingNoSwizzle | kShaderBasedSampling,
+    };
+
+    /**
+        In the main Skia API, the specifics of the SkImage used for the SkImage::makeShader call
+        can determine whether normal or YUV sampling is required. This entry point allows clients
+        to specify that the future image will be a YUV image.
+
+        @param shaderFlags Specify the sampling variations that will be precompiled.
+                           In practice, YUV images are rarely cubic-sampling.
+        @param colorInfos a span of SkColorInfos to narrow down the combinations.
+                          In general, the color info affects the swizzle and colorSpace
+                          transformation of the final Pipeline.
+        @return A precompile shader capturing the specified combinations
+    */
+    SK_API sk_sp<PrecompileShader> YUVImage(
+            YUVImageShaderFlags = YUVImageShaderFlags::kExcludeCubic,
+            SkSpan<const SkColorInfo> = {});
 
     // --- This block of two matches the SkShaders factories in SkPerlinNoiseShader.h
     // Again, most of the details have been elided.
     SK_API sk_sp<PrecompileShader> MakeFractalNoise();
     SK_API sk_sp<PrecompileShader> MakeTurbulence();
 
+    enum class GradientShaderFlags : uint16_t {
+        kNone    = 0,
+
+        kSmall   = 1 << 1,
+        kMedium  = 1 << 2,
+        kLarge   = 1 << 3,
+
+        kAll     = kSmall | kMedium | kLarge,
+        kNoLarge = kSmall | kMedium,
+    };
+
     // --- This block of four matches all the factories in SkGradientShader (SkGradientShader.h)
     SK_API sk_sp<PrecompileShader> LinearGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
             SkGradientShader::Interpolation = SkGradientShader::Interpolation());
     SK_API sk_sp<PrecompileShader> RadialGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
             SkGradientShader::Interpolation = SkGradientShader::Interpolation());
     SK_API sk_sp<PrecompileShader> TwoPointConicalGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
             SkGradientShader::Interpolation = SkGradientShader::Interpolation());
     SK_API sk_sp<PrecompileShader> SweepGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
             SkGradientShader::Interpolation = SkGradientShader::Interpolation());
 
     // Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the

package/cpp/skia/include/gpu/graphite/vk/precompile/VulkanPrecompileShader.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_vk_precompile_PrecompileShader_DEFINED
+#define skgpu_graphite_vk_precompile_PrecompileShader_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileShader.h"
+
+namespace skgpu {
+    struct VulkanYcbcrConversionInfo;
+}
+
+namespace skgpu::graphite {
+
+namespace PrecompileShaders {
+
+/**
+    In the main Skia API YCbCr Images are usually created by wrapping a BackendTexture.
+    Such backend textures are, in turn, created by a backend-specific entry point like:
+       BackendTextures::MakeVulkan(SkISize, const VulkanTextureInfo&, ...)
+    where the VulkanTextureInfo contains additional YCbCr information. This API cuts right to
+    providing the backend-specific YCbCr information (i.e., the VulkanYcbcrConversionInfo).
+
+    @return A precompile shader for a specific type of YCbCr image
+*/
+SK_API sk_sp<PrecompileShader> VulkanYCbCrImage(skgpu::VulkanYcbcrConversionInfo& YCbCrInfo,
+                                                ImageShaderFlags = ImageShaderFlags::kAll,
+                                                SkSpan<const SkColorInfo> = {},
+                                                SkSpan<const SkTileMode> = { kAllTileModes });
+
+} // namespace PrecompileShaders
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_vk_precompile_PrecompileShader_DEFINED

package/cpp/skia/include/gpu/vk/VulkanBackendContext.h

@@ -29,7 +29,7 @@ struct SK_API VulkanBackendContext {
     VkQueue                          fQueue = VK_NULL_HANDLE;
     uint32_t                         fGraphicsQueueIndex = 0;
     // The max api version set here should match the value set in VkApplicationInfo::apiVersion when
-    // then VkInstance was created.
+    // then VkInstance was created. Skia requires Vulkan 1.1 as the minimum version.
     uint32_t                         fMaxAPIVersion = 0;
     const skgpu::VulkanExtensions*   fVkExtensions = nullptr;
     // The client can create their VkDevice with either a VkPhysicalDeviceFeatures or