@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -59,15 +59,40 @@ public:
     /** Returns true if there is work that was submitted to the GPU that has not finished. */
     bool hasUnfinishedGpuWork() const;
 
-    void asyncRescaleAndReadPixels(const SkImage* image,
+    /** Makes image pixel data available to caller, possibly asynchronously. It can also rescale
+        the image pixels.
+
+        Data is read from the source sub-rectangle, is optionally converted to a linear gamma, is
+        rescaled to the size indicated by 'dstImageInfo', is then converted to the color space,
+        color type, and alpha type of 'dstImageInfo'. A 'srcRect' that is not contained by the
+        bounds of the image causes failure.
+
+        When the pixel data is ready the caller's ReadPixelsCallback is called with a
+        AsyncReadResult containing pixel data in the requested color type, alpha type, and color
+        space. The AsyncReadResult will have count() == 1. Upon failure the callback is called with
+        nullptr for AsyncReadResult. The callback can be triggered, for example, with a call to
+        Context::submit(SyncToCpu::kYes).
+
+        The data is valid for the lifetime of AsyncReadResult with the exception that the data is
+        immediately invalidated if the Graphite context is abandoned or destroyed.
+
+        @param src             Graphite-backed image or surface to read the data from.
+        @param dstImageInfo    info of the requested pixels
+        @param srcRect         subrectangle of image to read
+        @param rescaleGamma    controls whether rescaling is done in the image's gamma or whether
+                               the source data is transformed to a linear gamma before rescaling.
+        @param rescaleMode     controls the technique (and cost) of the rescaling
+        @param callback        function to call with result of the read
+        @param context         passed to callback
+    */
+    void asyncRescaleAndReadPixels(const SkImage* src,
                                    const SkImageInfo& dstImageInfo,
                                    const SkIRect& srcRect,
                                    SkImage::RescaleGamma rescaleGamma,
                                    SkImage::RescaleMode rescaleMode,
                                    SkImage::ReadPixelsCallback callback,
                                    SkImage::ReadPixelsContext context);
-
-    void asyncRescaleAndReadPixels(const SkSurface* surface,
+    void asyncRescaleAndReadPixels(const SkSurface* src,
                                    const SkImageInfo& dstImageInfo,
                                    const SkIRect& srcRect,
                                    SkImage::RescaleGamma rescaleGamma,
@@ -75,7 +100,35 @@ public:
                                    SkImage::ReadPixelsCallback callback,
                                    SkImage::ReadPixelsContext context);
 
-    void asyncRescaleAndReadPixelsYUV420(const SkImage*,
+    /**
+        Similar to asyncRescaleAndReadPixels but performs an additional conversion to YUV. The
+        RGB->YUV conversion is controlled by 'yuvColorSpace'. The YUV data is returned as three
+        planes ordered y, u, v. The u and v planes are half the width and height of the resized
+        rectangle. The y, u, and v values are single bytes. Currently this fails if 'dstSize'
+        width and height are not even. A 'srcRect' that is not contained by the bounds of the
+        surface causes failure.
+
+        When the pixel data is ready the caller's ReadPixelsCallback is called with a
+        AsyncReadResult containing the planar data. The AsyncReadResult will have count() == 3.
+        Upon failure the callback is called with nullptr for AsyncReadResult. The callback can
+        be triggered, for example, with a call to Context::submit(SyncToCpu::kYes).
+
+        The data is valid for the lifetime of AsyncReadResult with the exception that the data
+        is immediately invalidated if the context is abandoned or destroyed.
+
+        @param src            Graphite-backed image or surface to read the data from.
+        @param yuvColorSpace  The transformation from RGB to YUV. Applied to the resized image
+                              after it is converted to dstColorSpace.
+        @param dstColorSpace  The color space to convert the resized image to, after rescaling.
+        @param srcRect        The portion of the surface to rescale and convert to YUV planes.
+        @param dstSize        The size to rescale srcRect to
+        @param rescaleGamma   controls whether rescaling is done in the surface's gamma or whether
+                              the source data is transformed to a linear gamma before rescaling.
+        @param rescaleMode    controls the sampling technique of the rescaling
+        @param callback       function to call with the planar read result
+        @param context        passed to callback
+     */
+    void asyncRescaleAndReadPixelsYUV420(const SkImage* src,
                                          SkYUVColorSpace yuvColorSpace,
                                          sk_sp<SkColorSpace> dstColorSpace,
                                          const SkIRect& srcRect,
@@ -84,8 +137,7 @@ public:
                                          SkImage::RescaleMode rescaleMode,
                                          SkImage::ReadPixelsCallback callback,
                                          SkImage::ReadPixelsContext context);
-
-    void asyncRescaleAndReadPixelsYUV420(const SkSurface*,
+    void asyncRescaleAndReadPixelsYUV420(const SkSurface* src,
                                          SkYUVColorSpace yuvColorSpace,
                                          sk_sp<SkColorSpace> dstColorSpace,
                                          const SkIRect& srcRect,
@@ -95,7 +147,12 @@ public:
                                          SkImage::ReadPixelsCallback callback,
                                          SkImage::ReadPixelsContext context);
 
-    void asyncRescaleAndReadPixelsYUVA420(const SkImage*,
+    /**
+     * Identical to asyncRescaleAndReadPixelsYUV420 but a fourth plane is returned in the
+     * AsyncReadResult passed to 'callback'. The fourth plane contains the alpha chanel at the
+     * same full resolution as the Y plane.
+     */
+    void asyncRescaleAndReadPixelsYUVA420(const SkImage* src,
                                           SkYUVColorSpace yuvColorSpace,
                                           sk_sp<SkColorSpace> dstColorSpace,
                                           const SkIRect& srcRect,
@@ -104,8 +161,7 @@ public:
                                           SkImage::RescaleMode rescaleMode,
                                           SkImage::ReadPixelsCallback callback,
                                           SkImage::ReadPixelsContext context);
-
-    void asyncRescaleAndReadPixelsYUVA420(const SkSurface*,
+    void asyncRescaleAndReadPixelsYUVA420(const SkSurface* src,
                                           SkYUVColorSpace yuvColorSpace,
                                           sk_sp<SkColorSpace> dstColorSpace,
                                           const SkIRect& srcRect,
@@ -147,10 +203,21 @@ public:
     void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
     /**
-     * Returns the number of bytes of gpu memory currently budgeted in the Context's cache.
+     * Returns the number of bytes of the Context's gpu memory cache budget that are currently in
+     * use.
      */
     size_t currentBudgetedBytes() const;
 
+    /**
+     * Returns the number of bytes of the Context's resource cache that are currently purgeable.
+     */
+    size_t currentPurgeableBytes() const;
+
+    /**
+     * Returns the size of Context's gpu memory cache budget in bytes.
+     */
+    size_t maxBudgetedBytes() const;
+
     /**
      * Enumerates all cached GPU resources owned by the Context and dumps their memory to
      * traceMemoryDump.
@@ -163,6 +230,11 @@ public:
      */
     bool isDeviceLost() const;
 
+    /**
+     * Returns the maximum texture dimension supported by the underlying backend.
+     */
+    int maxTextureSize() const;
+
     /*
      * Does this context support protected content?
      */
@@ -219,42 +291,48 @@ private:
     // require Context::Make() to return a nullptr.
     bool finishInitialization();
 
-    void asyncRescaleAndReadPixelsYUV420Impl(const SkImage*,
-                                             SkYUVColorSpace yuvColorSpace,
-                                             bool readAlpha,
-                                             sk_sp<SkColorSpace> dstColorSpace,
-                                             const SkIRect& srcRect,
-                                             const SkISize& dstSize,
-                                             SkImage::RescaleGamma rescaleGamma,
-                                             SkImage::RescaleMode rescaleMode,
-                                             SkImage::ReadPixelsCallback callback,
-                                             SkImage::ReadPixelsContext context);
-
-    void asyncReadPixels(const TextureProxy* textureProxy,
-                         const SkImageInfo& srcImageInfo,
-                         const SkColorInfo& dstColorInfo,
-                         const SkIRect& srcRect,
-                         SkImage::ReadPixelsCallback callback,
-                         SkImage::ReadPixelsContext context);
-
-    void asyncReadPixelsYUV420(Recorder*,
-                               const SkImage*,
-                               SkYUVColorSpace yuvColorSpace,
-                               bool readAlpha,
-                               const SkIRect& srcRect,
-                               SkImage::ReadPixelsCallback callback,
-                               SkImage::ReadPixelsContext context);
-
-    void finalizeAsyncReadPixels(SkSpan<PixelTransferResult>,
-                                 SkImage::ReadPixelsCallback callback,
-                                 SkImage::ReadPixelsContext callbackContext);
-
-    // Inserts a texture to buffer transfer task, used by asyncReadPixels methods
-    PixelTransferResult transferPixels(const TextureProxy*,
-                                       const SkImageInfo& srcImageInfo,
+    void checkForFinishedWork(SyncToCpu);
+
+    std::unique_ptr<Recorder> makeInternalRecorder() const;
+
+    template <typename SrcPixels> struct AsyncParams;
+
+    template <typename ReadFn, typename... ExtraArgs>
+    void asyncRescaleAndReadImpl(ReadFn Context::* asyncRead,
+                                 SkImage::RescaleGamma rescaleGamma,
+                                 SkImage::RescaleMode rescaleMode,
+                                 const AsyncParams<SkImage>&,
+                                 ExtraArgs...);
+
+    // Recorder is optional and will be used if drawing operations are required. If no Recorder is
+    // provided but drawing operations are needed, a new Recorder will be created automatically.
+    void asyncReadPixels(std::unique_ptr<Recorder>, const AsyncParams<SkImage>&);
+    void asyncReadPixelsYUV420(std::unique_ptr<Recorder>,
+                               const AsyncParams<SkImage>&,
+                               SkYUVColorSpace);
+
+    // Like asyncReadPixels() except it performs no fallbacks, and requires that the texture be
+    // readable. However, the texture does not need to be sampleable.
+    void asyncReadTexture(std::unique_ptr<Recorder>,
+                          const AsyncParams<TextureProxy>&,
+                          const SkColorInfo& srcColorInfo);
+
+    // Inserts a texture to buffer transfer task, used by asyncReadPixels methods. If the
+    // Recorder is non-null, tasks will be added to the Recorder's list; otherwise the transfer
+    // tasks will be added to the queue manager directly.
+    PixelTransferResult transferPixels(Recorder*,
+                                       const TextureProxy* srcProxy,
+                                       const SkColorInfo& srcColorInfo,
                                        const SkColorInfo& dstColorInfo,
                                        const SkIRect& srcRect);
 
+    // If the recorder is non-null, it will be snapped and inserted with the assumption that the
+    // copy tasks (and possibly preparatory draw tasks) have already been added to the Recording.
+    void finalizeAsyncReadPixels(std::unique_ptr<Recorder>,
+                                 SkSpan<PixelTransferResult>,
+                                 SkImage::ReadPixelsCallback callback,
+                                 SkImage::ReadPixelsContext callbackContext);
+
     sk_sp<SharedContext> fSharedContext;
     std::unique_ptr<ResourceProvider> fResourceProvider;
     std::unique_ptr<QueueManager> fQueueManager;
@@ -264,7 +342,7 @@ private:
     // ResourceCache for the Context.
     mutable SingleOwner fSingleOwner;
 
-#if defined(GRAPHITE_TEST_UTILS)
+#if defined(GPU_TEST_UTILS)
     // In test builds a Recorder may track the Context that was used to create it.
     bool fStoreContextRefInRecorder = false;
     // If this tracking is on, to allow the client to safely delete this Context or its Recorders

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

@@ -11,6 +11,8 @@
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
+#include <optional>
+
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -71,10 +73,15 @@ struct SK_API ContextOptions {
 #endif
 
     /**
-     * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
-     * fGlypheCacheTextureMaximumBytes.
+     * The maximum size of textures used for Skia's PathAtlas caches.
+     */
+    int fMaxPathAtlasTextureSize = 8192;  // oversized, PathAtlas will likely be smaller
+
+    /**
+     * Can the glyph and path atlases use multiple textures. If allowed, each texture's size is
+     * bound by fGlyphCacheTextureMaximumBytes and fMaxPathAtlasTextureSize, respectively.
      */
-    bool fAllowMultipleGlyphCacheTextures = true;
+    bool fAllowMultipleAtlasTextures = true;
     bool fSupportBilerpFromGlyphAtlas = false;
 
     /**
@@ -91,6 +98,26 @@ struct SK_API ContextOptions {
      */
     size_t fGpuBudgetInBytes = kDefaultContextBudget;
 
+    /**
+     * Whether labels will be set on backend resources.
+     */
+#if defined(SK_DEBUG)
+    bool fSetBackendLabels = true;
+#else
+    bool fSetBackendLabels = false;
+#endif
+
+    /**
+     * If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
+     * for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
+     * inernally defined default size.
+     *
+     * However, it is highly discouraged to have Skia make a default allocator (and support for
+     * doing so will be removed soon,  b/321962001). Instead clients should create their own
+     * allocator to pass into Skia where they can fine tune this value themeselves.
+     */
+    std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

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

@@ -103,25 +103,53 @@ enum class Volatile : bool {
     kYes = true               // fulfilled on every insertion call
 };
 
-/*
- * Graphite's different rendering methods each only apply to certain types of draws. This
- * enum supports decision-making regarding the different renderers and what is being drawn.
- */
-enum DrawTypeFlags : uint8_t {
-
+enum class DepthStencilFlags : int {
     kNone         = 0b000,
+    kDepth        = 0b001,
+    kStencil      = 0b010,
+    kDepthStencil = kDepth | kStencil,
+};
 
-    // SkCanvas:: drawSimpleText, drawString, drawGlyphs, drawTextBlob, drawSlug
-    kText         = 0b001,
-
-    // SkCanvas::drawVertices
-    kDrawVertices = 0b010,
-
-    // All other canvas draw calls
-    kShape        = 0b100,
-
-    kMostCommon = kText | kShape,
-    kAll = kText | kDrawVertices | kShape
+/*
+ * This enum allows mapping from a set of observed RenderSteps (e.g., from a GraphicsPipeline
+ * printout) to the correct 'drawTypes' parameter needed by the Precompilation API.
+ */
+enum DrawTypeFlags : uint16_t {
+
+    kNone             = 0b000000000,
+
+    // kBitmapText_Mask should be used for the BitmapTextRenderStep[mask] RenderStep
+    kBitmapText_Mask  = 0b00000001,
+    // kBitmapText_LCD should be used for the BitmapTextRenderStep[LCD] RenderStep
+    kBitmapText_LCD   = 0b00000010,
+    // kBitmapText_Color should be used for the BitmapTextRenderStep[color] RenderStep
+    kBitmapText_Color = 0b00000100,
+    // kSDFText should be used for the SDFTextRenderStep RenderStep
+    kSDFText          = 0b00001000,
+    // kSDFText_LCD should be used for the SDFTextLCDRenderStep RenderStep
+    kSDFText_LCD      = 0b00010000,
+
+    // 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,
+
+    // kSimpleShape should be used to generate Pipelines that use the following RenderSteps:
+    //    AnalyticBlurRenderStep
+    //    AnalyticRRectRenderStep
+    //    PerEdgeAAQuadRenderStep
+    //    CoverBoundsRenderStep[non-aa-fill]
+    kSimpleShape      = 0b01000000,
+
+    // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps:
+    //    CoverageMaskRenderStep
+    //    CoverBoundsRenderStep[*] for [inverse-cover], [regular-cover]
+    //    TessellateStrokeRenderStep
+    //    TessellateWedgesRenderStep[*] for [convex], [evenodd], [winding]
+    //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
+    //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
+    kNonSimpleShape   = 0b10000000,
 };
 
 } // namespace skgpu::graphite

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

@@ -14,6 +14,8 @@
 #include "include/core/SkSpan.h"
 #include "include/gpu/GpuTypes.h"
 
+#include <string_view>
+
 class SkYUVAInfo;
 class SkYUVAPixmaps;
 struct SkIRect;
@@ -28,21 +30,21 @@ namespace skgpu::graphite {
 }
 
 namespace SkImages {
+enum class GenerateMipmapsFromBase : bool { kNo, kYes };
+
 using TextureReleaseProc = void (*)(ReleaseContext);
 
-// Passed to both non-YUVA fulfill and imageRelease
+// Passed to imageRelease
 using GraphitePromiseImageContext = void*;
-// Passed to YUVA fulfill
-using GraphitePromiseTextureContext = void*;
+// Passed to fulfill; for non-YUVA promise images, the image context is used as the fulfill context,
+// while YUVA promise images have a per-plane fulfill context.
+using GraphitePromiseTextureFulfillContext = void*;
 // Returned from fulfill and passed into textureRelease
 using GraphitePromiseTextureReleaseContext = void*;
 
-using GraphitePromiseImageFulfillProc =
+using GraphitePromiseTextureFulfillProc =
         std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)(
-                GraphitePromiseImageContext);
-using GraphitePromiseImageYUVAFulfillProc =
-        std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)(
-                GraphitePromiseTextureContext);
+                GraphitePromiseTextureFulfillContext);
 using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
 using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);
 
@@ -52,18 +54,24 @@ using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureRelease
     SkImage is returned if the format of backendTexture is recognized and supported.
     Recognized formats vary by GPU back-end.
 
-    @param recorder            The recorder
-    @param backendTexture      texture residing on GPU
-    @param colorSpace          This describes the color space of this image's contents, as
-                               seen after sampling. In general, if the format of the backend
-                               texture is SRGB, some linear colorSpace should be supplied
-                               (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
-                               backend texture is linear, then the colorSpace should include
-                               a description of the transfer function as
-                               well (e.g., SkColorSpace::MakeSRGB()).
-    @param origin              Whether the Texture logically treats the origin as TopLeft or
-                               BottomLeft
-    @return                    created SkImage, or nullptr
+    @param recorder                The recorder
+    @param backendTexture          texture residing on GPU
+    @param colorSpace              This describes the color space of this image's contents, as
+                                   seen after sampling. In general, if the format of the backend
+                                   texture is SRGB, some linear colorSpace should be supplied
+                                   (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
+                                   backend texture is linear, then the colorSpace should include
+                                   a description of the transfer function as
+                                   well (e.g., SkColorSpace::MakeSRGB()).
+    @param origin                  Whether the Texture logically treats the origin as TopLeft or
+                                   BottomLeft
+    @param generateMipmapsFromBase If kYes then the pixel contents of the textures upper mipmap
+                                   levels are generated by successive downsampling of the base
+                                   level. If the texture is not mipmapped or isn't renderable then
+                                   image creation will fail. If kNo and the texture is mipmapped
+                                   then the contents of upper levels are assumed to already be
+                                   valid.
+    @return                        created SkImage, or nullptr
 */
 SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                   const skgpu::graphite::BackendTexture&,
@@ -71,39 +79,29 @@ SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                   SkAlphaType alphaType,
                                   sk_sp<SkColorSpace> colorSpace,
                                   skgpu::Origin origin,
+                                  GenerateMipmapsFromBase generateMipmapsFromBase,
                                   TextureReleaseProc = nullptr,
-                                  ReleaseContext = nullptr);
+                                  ReleaseContext = nullptr,
+                                  std::string_view label = {});
 
 SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                   const skgpu::graphite::BackendTexture&,
                                   SkColorType colorType,
                                   SkAlphaType alphaType,
                                   sk_sp<SkColorSpace> colorSpace,
+                                  skgpu::Origin origin,
                                   TextureReleaseProc = nullptr,
-                                  ReleaseContext = nullptr);
-
-#if !defined(SK_DISABLE_LEGACY_GRAPHITE_IMAGES)
-inline sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder* recorder,
-                                       const skgpu::graphite::BackendTexture& tex,
-                                       SkColorType colorType,
-                                       SkAlphaType alphaType,
-                                       sk_sp<SkColorSpace> colorSpace,
-                                       skgpu::Origin origin,
-                                       TextureReleaseProc trProc = nullptr,
-                                       ReleaseContext ctx = nullptr) {
-    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, origin, trProc, ctx);
-}
+                                  ReleaseContext = nullptr,
+                                  std::string_view label = {});
 
-inline sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder* recorder,
-                                       const skgpu::graphite::BackendTexture& tex,
-                                       SkColorType colorType,
-                                       SkAlphaType alphaType,
-                                       sk_sp<SkColorSpace> colorSpace,
-                                       TextureReleaseProc trProc = nullptr,
-                                       ReleaseContext ctx = nullptr) {
-    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, trProc, ctx);
-}
-#endif
+SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
+                                  const skgpu::graphite::BackendTexture&,
+                                  SkColorType colorType,
+                                  SkAlphaType alphaType,
+                                  sk_sp<SkColorSpace> colorSpace,
+                                  TextureReleaseProc = nullptr,
+                                  ReleaseContext = nullptr,
+                                  std::string_view label = {});
 
 /** Create a new SkImage that is very similar to an SkImage created by WrapTexture. The difference
     is that the caller need not have created the backend texture nor populated it with data when
@@ -156,17 +154,18 @@ SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                          const SkColorInfo&,
                                          skgpu::Origin origin,
                                          skgpu::graphite::Volatile,
-                                         GraphitePromiseImageFulfillProc,
+                                         GraphitePromiseTextureFulfillProc,
                                          GraphitePromiseImageReleaseProc,
                                          GraphitePromiseTextureReleaseProc,
-                                         GraphitePromiseImageContext);
+                                         GraphitePromiseImageContext,
+                                         std::string_view label = {});
 
 SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                          SkISize dimensions,
                                          const skgpu::graphite::TextureInfo&,
                                          const SkColorInfo&,
                                          skgpu::graphite::Volatile,
-                                         GraphitePromiseImageFulfillProc,
+                                         GraphitePromiseTextureFulfillProc,
                                          GraphitePromiseImageReleaseProc,
                                          GraphitePromiseTextureReleaseProc,
                                          GraphitePromiseImageContext);
@@ -176,8 +175,8 @@ SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
     and A are all in different planes and thus the image is specified by four textures.
     'backendTextureInfo' describes the planar arrangement, texture formats, and conversion to RGB.
     Separate 'fulfill' and 'textureRelease' calls are made for each texture. Each texture has its
-    own GraphitePromiseTextureContext. The GraphitePromiseImageReleaseProc will be made even on
-    failure. 'textureContexts' has one entry for each of the up to four textures, as indicated by
+    own GraphitePromiseFulfillContext. The GraphitePromiseImageReleaseProc will be made even on
+    failure. 'planeContexts' has one entry for each of the up to four textures, as indicated by
     'backendTextureInfo'. Currently the mipmapped property of 'backendTextureInfo' is ignored.
     However, in the near future it will be required that if it is kYes then the fulfillProc must
     return a mip mapped texture for each plane in order to successfully draw the image.
@@ -192,18 +191,19 @@ SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
     @param imageRelease        function called when any image-centric data can be deleted
     @param textureRelease      function called when the backend texture can be deleted
     @param imageContext        state passed to imageRelease
-    @param textureContexts     states passed to fulfill and textureRelease
+    @param planeContexts       states passed to fulfill for each plane
     @return                    created SkImage, or nullptr
 */
 SK_API sk_sp<SkImage> PromiseTextureFromYUVA(skgpu::graphite::Recorder*,
                                              const skgpu::graphite::YUVABackendTextureInfo&,
                                              sk_sp<SkColorSpace> imageColorSpace,
                                              skgpu::graphite::Volatile,
-                                             GraphitePromiseImageYUVAFulfillProc,
+                                             GraphitePromiseTextureFulfillProc,
                                              GraphitePromiseImageReleaseProc,
                                              GraphitePromiseTextureReleaseProc,
                                              GraphitePromiseImageContext imageContext,
-                                             GraphitePromiseTextureContext textureContexts[]);
+                                             GraphitePromiseTextureFulfillContext planeContexts[],
+                                             std::string_view label = {});
 
 
 /** Returns an SkImage backed by a Graphite texture, using the provided Recorder for creation and
@@ -259,7 +259,8 @@ SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(skgpu::graphite::Recorder*,
                                              const SkYUVAPixmaps& pixmaps,
                                              SkImage::RequiredProperties = {},
                                              bool limitToMaxTextureSize = false,
-                                             sk_sp<SkColorSpace> imgColorSpace = nullptr);
+                                             sk_sp<SkColorSpace> imgColorSpace = nullptr,
+                                             std::string_view label = {});
 
 /** Creates an SkImage from YUV[A] planar textures associated with the recorder.
      @param recorder            The recorder.
@@ -276,7 +277,8 @@ SK_API sk_sp<SkImage> TextureFromYUVATextures(
         const skgpu::graphite::YUVABackendTextures& yuvaBackendTextures,
         sk_sp<SkColorSpace> imageColorSpace,
         TextureReleaseProc = nullptr,
-        ReleaseContext = nullptr);
+        ReleaseContext = nullptr,
+        std::string_view label = {});
 
 /** Creates an SkImage from YUV[A] planar SkImages associated with the recorder.