rngine 0.7.2 → 0.8.1

package/shared/skia/include/gpu/graphite/precompile/PrecompileMaskFilter.h

@@ -0,0 +1,49 @@
+/*
+ * 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 skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED
+#define skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include "include/gpu/graphite/precompile/PaintOptions.h"
+
+namespace skgpu::graphite {
+
+/** \class PrecompileMaskFilter
+    This class corresponds to the SkMaskFilter class in the main API.
+*/
+class SK_API PrecompileMaskFilter : public PrecompileBase {
+protected:
+    friend class PaintOptions;  // for createPipelines() access
+
+    PrecompileMaskFilter() : PrecompileBase(Type::kMaskFilter) {}
+    ~PrecompileMaskFilter() override;
+
+    void addToKey(const KeyContext&, int desiredCombination) const final;
+
+    virtual void createPipelines(const KeyContext&,
+                                 const PaintOptions&,
+                                 const RenderPassDesc&,
+                                 const PaintOptions::ProcessCombination&) const = 0;
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkMaskFilter class' factories in the main API
+namespace PrecompileMaskFilters {
+
+    // This corresponds to the SkMaskFilter::MakeBlur factory in the main Skia API.
+    // The specific details of the blur have been elided since they don't impact the generated
+    // shader.
+    SK_API sk_sp<PrecompileMaskFilter> Blur();
+
+} // namespace PrecompileMaskFilters
+
+} // namespace skgpu::graphite
+
+
+#endif // skgpu_graphite_precompile_PrecompileMaskFilter_DEFINED

package/shared/skia/include/gpu/graphite/precompile/PrecompileRuntimeEffect.h

@@ -0,0 +1,47 @@
+/*
+ * 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 skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED
+#define skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+
+class SkRuntimeEffect;
+
+namespace skgpu::graphite {
+
+class PrecompileBase;
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileShader;
+
+using PrecompileChildOptions = SkSpan<const sk_sp<PrecompileBase>>;
+
+//--------------------------------------------------------------------------------------------------
+// These factory functions correspond to the main API's SkRuntimeEffect makeShader, makeColorFilter,
+// and makeBlender functions. The uniform values found in the main API are abstracted away since
+// they do not alter the generated code.
+namespace PrecompileRuntimeEffects {
+
+SK_API sk_sp<PrecompileShader> MakePrecompileShader(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+SK_API sk_sp<PrecompileColorFilter> MakePrecompileColorFilter(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+SK_API sk_sp<PrecompileBlender> MakePrecompileBlender(
+        sk_sp<SkRuntimeEffect> effect,
+        SkSpan<const PrecompileChildOptions> childOptions = {});
+
+} // namespace PrecompileRuntimeEffects
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileRuntimeEffect_DEFINED

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

@@ -0,0 +1,268 @@
+/*
+ * 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 skgpu_graphite_precompile_PrecompileShader_DEFINED
+#define skgpu_graphite_precompile_PrecompileShader_DEFINED
+
+#include "include/gpu/graphite/precompile/PrecompileBase.h"
+
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkImageInfo.h"
+#include "include/effects/SkGradient.h"
+
+class SkColorSpace;
+
+namespace skgpu::graphite {
+
+class PrecompileBlender;
+class PrecompileColorFilter;
+class PrecompileShaderPriv;
+
+/** \class PrecompileShader
+    This class corresponds to the SkShader class in the main API.
+*/
+class SK_API PrecompileShader : public PrecompileBase {
+public:
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithLocalMatrix. The actual matrix
+     *  involved is abstracted away, except for whether or the not the matrix involves perspective
+     *  so the correct generated shader variation is chosen.
+     *  The PrecompileShaders::LocalMatrix factory can be used to generate a set of shaders
+     *  that would've been generated via multiple makeWithLocalMatrix calls. That is, rather than
+     *  performing:
+     *     sk_sp<PrecompileShader> option1 = source1->makeWithLocalMatrix(false);
+     *     sk_sp<PrecompileShader> option2 = source2->makeWithLocalMatrix(false);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = LocalMatrix({ source1, source2 }, false);
+     */
+    sk_sp<PrecompileShader> makeWithLocalMatrix(bool isPerspective) const;
+
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithColorFilter.
+     *  The PrecompileShaders::ColorFilter factory can be used to generate a set of shaders that
+     *  would've been generated via multiple makeWithColorFilter calls. That is, rather than
+     *  performing:
+     *     sk_sp<PrecompileShader> option1 = source->makeWithColorFilter(colorFilter1);
+     *     sk_sp<PrecompileShader> option2 = source->makeWithColorFilter(colorFilter2);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source },
+     *                                                           { colorFilter1, colorFilter2 });
+     *  With an alternative use case one could also use the ColorFilter factory thusly:
+     *     sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source1, source2 },
+     *                                                           { colorFilter });
+     */
+    sk_sp<PrecompileShader> makeWithColorFilter(sk_sp<PrecompileColorFilter>) const;
+
+    /**
+     *  This is the Precompile correlate to SkShader::makeWithWorkingColorSpace.
+     *  The PrecompileShaders::WorkingColorSpace factory can be used to generate a set of shaders
+     *  that would've been generated via multiple makeWithWorkingColorSpace calls. That is, rather
+     *  than performing:
+     *     sk_sp<PrecompileShader> option1 = source->makeWithWorkingColorSpace(colorSpace1);
+     *     sk_sp<PrecompileShader> option2 = source->makeWithWorkingColorSpace(colorSpace2);
+     *  one could call:
+     *     sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source },
+     *                                                                 { colorSpace1,
+     *                                                                   colorSpace2 });
+     *  With an alternative use case one could also use the WorkingColorSpace factory thusly:
+     *     sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source1, source2 },
+     *                                                                 { colorSpace });
+     */
+    sk_sp<PrecompileShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace> inputCS,
+                                                      sk_sp<SkColorSpace> outputCS=nullptr) const;
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileShaderPriv priv();
+    const PrecompileShaderPriv priv() const;  // NOLINT(readability-const-return-type)
+
+protected:
+    friend class PrecompileShaderPriv;
+
+    PrecompileShader() : PrecompileBase(Type::kShader) {}
+    ~PrecompileShader() override;
+
+    virtual bool isConstant(int /* desiredCombination */) const { return false; }
+    virtual bool isOpaque(int /* desiredCombination */) const = 0;
+
+    virtual bool isALocalMatrixShader() const { return false; }
+};
+
+//--------------------------------------------------------------------------------------------------
+// This is the Precompile correlate to the SkShaders namespace in the main API
+namespace PrecompileShaders {
+    // --- This block of eight matches the SkShaders factories in SkShader.h
+    // Note that some of the details of the main API have been elided since they don't impact
+    // the generated shader (e.g., the color parameter to the Color() factories).
+    SK_API sk_sp<PrecompileShader> Empty();
+    SK_API sk_sp<PrecompileShader> Color();
+    SK_API sk_sp<PrecompileShader> Color(sk_sp<SkColorSpace>);
+    SK_API sk_sp<PrecompileShader> Blend(SkSpan<const SkBlendMode> blendModes,
+                                         SkSpan<const sk_sp<PrecompileShader>> dsts,
+                                         SkSpan<const sk_sp<PrecompileShader>> srcs);
+    SK_API sk_sp<PrecompileShader> Blend(SkSpan<const sk_sp<PrecompileBlender>> blenders,
+                                         SkSpan<const sk_sp<PrecompileShader>> dsts,
+                                         SkSpan<const sk_sp<PrecompileShader>> srcs);
+    SK_API sk_sp<PrecompileShader> CoordClamp(SkSpan<const sk_sp<PrecompileShader>>);
+
+    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(ImageShaderFlags = ImageShaderFlags::kExcludeCubic,
+                                            SkSpan<const SkColorInfo> = {},
+                                            SkSpan<const SkTileMode> = { kAllTileModes });
+
+    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 (SkGradient.h)
+    SK_API sk_sp<PrecompileShader> LinearGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
+            SkGradient::Interpolation = SkGradient::Interpolation());
+    SK_API sk_sp<PrecompileShader> RadialGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
+            SkGradient::Interpolation = SkGradient::Interpolation());
+    SK_API sk_sp<PrecompileShader> TwoPointConicalGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
+            SkGradient::Interpolation = SkGradient::Interpolation());
+    SK_API sk_sp<PrecompileShader> SweepGradient(
+            GradientShaderFlags = GradientShaderFlags::kAll,
+            SkGradient::Interpolation = SkGradient::Interpolation());
+
+    // Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the
+    // SkPicture to be drawn, most likely, won't be available at precompilation time, this
+    // entry point can be used to create a precompilation equivalent.
+    // Note: this will precompile the program that draws the SkPicture. It, obviously, won't
+    // precompile any SkPaints within the SkPicture.
+    SK_API sk_sp<PrecompileShader> Picture();
+
+    // Normally, LocalMatrixShaders are only created via SkShader::makeWithLocalMatrix.
+    // However, in the combination API, clients may want to create a set of precompile
+    // LocalMatrixShaders (i.e., pass an SkSpan to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithLocalMatrix() can still be used and works as expected.
+    SK_API sk_sp<PrecompileShader> LocalMatrix(SkSpan<const sk_sp<PrecompileShader>> wrapped,
+                                               bool isPerspective = false);
+
+    // Normally, ColorFilterShaders are only created via SkShader::makeWithColorFilter.
+    // However, in the combination API, clients may want to create a set of precompile
+    // ColorFilterShaders (i.e., pass SkSpans to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithColorFilter can still be used and works as expected.
+    SK_API sk_sp<PrecompileShader> ColorFilter(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const sk_sp<PrecompileColorFilter>> colorFilters);
+
+    // Normally, WorkingColorSpaceShaders are only created via SkShader::makeWithWorkingColorSpace.
+    // However, in the combination API, clients may want to create a set of precompile
+    // WorkingColorSpaceShaders (i.e., pass SkSpans to the factory function vs just creating a
+    // single option). This entry point allows that use case.
+    // Note: PrecompileShader::makeWithWorkingColorSpace can still be used and works as expected.
+
+    // This variant creates the cross product of `inputSpaces` and `outputSpaces`.
+    // An empty list is interpreted as matching either the dst color space (for `inputSpaces`) or
+    // matching the input space (for `outputSpaces`).
+    SK_API sk_sp<PrecompileShader> WorkingColorSpace(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const sk_sp<SkColorSpace>> inputSpaces,
+            SkSpan<const sk_sp<SkColorSpace>> outputSpaces = {});
+
+    // This variant takes a span of input and output color spaces pairs explicitly.
+    SK_API sk_sp<PrecompileShader> WorkingColorSpaceExplicit(
+            SkSpan<const sk_sp<PrecompileShader>> shaders,
+            SkSpan<const std::pair</*input =*/sk_sp<SkColorSpace>,
+                                   /*output=*/sk_sp<SkColorSpace>>> inputAndOutputSpaces);
+
+} // namespace PrecompileShaders
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_precompile_PrecompileShader_DEFINED

package/shared/skia/include/gpu/graphite/vk/VulkanGraphiteContext.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2022 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_VulkanGraphiteUtils_DEFINED
+#define skgpu_graphite_VulkanGraphiteUtils_DEFINED
+
+#include <memory>
+
+#include "include/private/SkAPI.h"
+
+// NOTE: Because there is already a VulkanBackendContext header shared between Ganesh and Graphite,
+// this is named VulkanGraphiteContext.h to supply just the factory function (differing from the
+// public headers exposed by other backends).
+namespace skgpu { struct VulkanBackendContext; }
+
+namespace skgpu::graphite {
+
+class Context;
+struct ContextOptions;
+
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeVulkan(const VulkanBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_VulkanGraphiteUtils_DEFINED

package/shared/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2022 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_VulkanGraphiteTypes_DEFINED
+#define skgpu_graphite_VulkanGraphiteTypes_DEFINED
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/gpu/vk/VulkanTypes.h"
+
+namespace skgpu::graphite {
+
+class SK_API VulkanTextureInfo final : public TextureInfo::Data {
+public:
+    // VkImageCreateInfo properties
+    // Currently the only supported flags are VK_IMAGE_CREATE_PROTECTED_BIT and, when
+    // VK_EXT_multisampled_render_to_single_sampled is present and enabled,
+    // VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT. Other flags are not accepted.
+    VkImageCreateFlags fFlags = 0;
+    VkFormat           fFormat = VK_FORMAT_UNDEFINED;
+    VkImageTiling      fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    VkImageUsageFlags  fImageUsageFlags = 0;
+    VkSharingMode      fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+    // Properties related to the image view and sampling. These are less inherent properties of the
+    // VkImage but describe how the VkImage should be used within Skia.
+
+    // What aspect to use for the VkImageView. The normal, default is VK_IMAGE_ASPECT_COLOR_BIT.
+    // However, if the VkImage is a Ycbcr format, the client can pass a specific plan here to have
+    // Skia directly sample a plane. In that case the client should also pass in a VkFormat that is
+    // compatible with the plane as described by the Vulkan spec.
+    VkImageAspectFlags        fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VulkanYcbcrConversionInfo fYcbcrConversionInfo;
+
+    VulkanTextureInfo() = default;
+    VulkanTextureInfo(VkSampleCountFlagBits sampleCount,
+                      Mipmapped mipmapped,
+                      VkImageCreateFlags flags,
+                      VkFormat format,
+                      VkImageTiling imageTiling,
+                      VkImageUsageFlags imageUsageFlags,
+                      VkSharingMode sharingMode,
+                      VkImageAspectFlags aspectMask,
+                      VulkanYcbcrConversionInfo ycbcrConversionInfo)
+            // VkSampleCountFlagBits is value equivalent to SampleCount
+            : Data(static_cast<SampleCount>(sampleCount), mipmapped)
+            , fFlags(flags)
+            , fFormat(format)
+            , fImageTiling(imageTiling)
+            , fImageUsageFlags(imageUsageFlags)
+            , fSharingMode(sharingMode)
+            , fAspectMask(aspectMask)
+            , fYcbcrConversionInfo(ycbcrConversionInfo) {}
+
+private:
+    friend class TextureInfo;
+    friend class TextureInfoPriv;
+
+    // Non-virtual template API for TextureInfo::Data accessed directly when backend type is known.
+    static constexpr skgpu::BackendApi kBackend = skgpu::BackendApi::kVulkan;
+
+    Protected isProtected() const {
+        return fFlags & VK_IMAGE_CREATE_PROTECTED_BIT ? Protected::kYes : Protected::kNo;
+    }
+    TextureFormat viewFormat() const;
+
+    // Virtual API when the specific backend type is not available.
+    SkString toBackendString() const override;
+
+    void copyTo(TextureInfo::AnyTextureInfoData& dstData) const override {
+        dstData.emplace<VulkanTextureInfo>(*this);
+    }
+    bool isCompatible(const TextureInfo& that, bool requireExact) const override;
+};
+
+namespace TextureInfos {
+SK_API TextureInfo MakeVulkan(const VulkanTextureInfo&);
+
+SK_API bool GetVulkanTextureInfo(const TextureInfo&, VulkanTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+SK_API BackendTexture MakeVulkan(SkISize dimensions,
+                                 const VulkanTextureInfo&,
+                                 VkImageLayout,
+                                 uint32_t queueFamilyIndex,
+                                 VkImage,
+                                 VulkanAlloc);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+SK_API BackendSemaphore MakeVulkan(VkSemaphore);
+
+SK_API VkSemaphore GetVkSemaphore(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_VulkanGraphiteTypes_DEFINED

package/shared/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(const 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/shared/skia/include/gpu/mtl/MtlMemoryAllocator.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_MtlMemoryAllocator_DEFINED
+#define skgpu_MtlMemoryAllocator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#ifdef __APPLE__
+
+#ifdef __OBJC__
+#import <Metal/Metal.h>
+#endif
+
+namespace skgpu {
+
+// interface classes for the GPU memory allocator
+class MtlAlloc : public SkRefCnt {
+public:
+    ~MtlAlloc() override = default;
+};
+
+#ifdef __OBJC__
+class MtlMemoryAllocator : public SkRefCnt {
+public:
+    virtual id<MTLBuffer> newBufferWithLength(NSUInteger length, MTLResourceOptions options,
+                                              sk_sp<MtlAlloc>* allocation) = 0;
+    virtual id<MTLTexture> newTextureWithDescriptor(MTLTextureDescriptor* texDesc,
+                                                    sk_sp<MtlAlloc>* allocation) = 0;
+};
+#endif
+
+}  // namespace skgpu
+
+#endif // __APPLE__
+
+#endif // skgpu_MtlMemoryAllocator_DEFINED

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_VulkanBackendContext_DEFINED
+#define skgpu_VulkanBackendContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/vk/VulkanMemoryAllocator.h"
+#include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+
+namespace skgpu {
+
+class VulkanExtensions;
+
+// The VkBackendContext contains all of the base Vk objects needed by the skia Vulkan context.
+struct SK_API VulkanBackendContext {
+    VkInstance                       fInstance = VK_NULL_HANDLE;
+    VkPhysicalDevice                 fPhysicalDevice = VK_NULL_HANDLE;
+    VkDevice                         fDevice = VK_NULL_HANDLE;
+    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. 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
+    // VkPhysicalDeviceFeatures2 struct, thus we have to support taking both. The
+    // VkPhysicalDeviceFeatures2 struct is needed so we know if the client enabled any extension
+    // specific features. If fDeviceFeatures2 is not null then we ignore fDeviceFeatures. If both
+    // fDeviceFeatures and fDeviceFeatures2 are null we will assume no features are enabled.
+    const VkPhysicalDeviceFeatures*  fDeviceFeatures = nullptr;
+    const VkPhysicalDeviceFeatures2* fDeviceFeatures2 = nullptr;
+    // The client must provide an inplementation of a VulkanMemoryAllocator for Skia to use
+    // for allocating Vulkan resources that use VkDeviceMemory.
+    sk_sp<VulkanMemoryAllocator>     fMemoryAllocator;
+    skgpu::VulkanGetProc             fGetProc;
+    Protected                        fProtectedContext = Protected::kNo;
+    // Optional callback which will be invoked if a VK_ERROR_DEVICE_LOST error code is received from
+    // the driver. Debug information from the driver will be provided to the callback if the
+    // VK_EXT_device_fault extension is supported and enabled (VkPhysicalDeviceFaultFeaturesEXT must
+    // be in the pNext chain of VkDeviceCreateInfo).
+    skgpu::VulkanDeviceLostContext   fDeviceLostContext = nullptr;
+    skgpu::VulkanDeviceLostProc      fDeviceLostProc = nullptr;
+};
+
+}  // namespace skgpu
+
+#endif // skgpu_VulkanBackendContext_DEFINED