@shopify/react-native-skia 0.1.191 → 0.1.193

package/cpp/skia/include/core/SkImage.h

@@ -8,581 +8,252 @@
 #ifndef SkImage_DEFINED
 #define SkImage_DEFINED
 
+#include "include/core/SkAlphaType.h"
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkSamplingOptions.h"
-#include "include/core/SkScalar.h"
-#include "include/core/SkShader.h"
-#include "include/core/SkSurfaceProps.h"
-#include "include/core/SkTileMode.h"
-#if SK_SUPPORT_GPU
-#include "include/gpu/GrTypes.h"
-#endif
-#if defined(SK_GRAPHITE_ENABLED)
+#include "include/core/SkSize.h"
+#include "include/private/base/SkAPI.h"
+
+#if defined(SK_GRAPHITE)
 #include "include/gpu/graphite/GraphiteTypes.h"
+class SkYUVAPixmaps;
 #endif
-#include <functional>  // std::function
-#include <optional>
 
-#if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
-#include <android/hardware_buffer.h>
-#endif
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
 
-class GrBackendFormat;
-class GrBackendTexture;
-class GrContextThreadSafeProxy;
 class GrDirectContext;
 class GrRecordingContext;
-class GrYUVABackendTextureInfo;
-class GrYUVABackendTextures;
-class SkCanvas;
+class SkBitmap;
+class SkColorSpace;
 class SkData;
 class SkImage;
 class SkImageFilter;
 class SkImageGenerator;
+class SkMatrix;
 class SkMipmap;
 class SkPaint;
 class SkPicture;
 class SkPixmap;
-class SkPromiseImageTexture;
-class SkSurface;
-class SkYUVAPixmaps;
+class SkShader;
+class SkSurfaceProps;
+enum SkColorType : int;
+enum class SkTextureCompressionType;
+enum class SkTileMode;
 
-enum class SkEncodedImageFormat;
+struct SkIPoint;
+struct SkSamplingOptions;
 
-#if defined(SK_GRAPHITE_ENABLED)
+#if defined(SK_GRAPHITE)
 namespace skgpu::graphite {
 class BackendTexture;
 class Recorder;
-};
+class TextureInfo;
+enum class Volatile : bool;
+class YUVABackendTextures;
+}
 #endif
 
-/** \class SkImage
-    SkImage describes a two dimensional array of pixels to draw. The pixels may be
-    decoded in a raster bitmap, encoded in a SkPicture or compressed data stream,
-    or located in GPU memory as a GPU texture.
-
-    SkImage cannot be modified after it is created. SkImage may allocate additional
-    storage as needed; for instance, an encoded SkImage may decode when drawn.
+namespace SkImages {
 
-    SkImage width and height are greater than zero. Creating an SkImage with zero width
-    or height returns SkImage equal to nullptr.
-
-    SkImage may be created from SkBitmap, SkPixmap, SkSurface, SkPicture, encoded streams,
-    GPU texture, YUV_ColorSpace data, or hardware buffer. Encoded streams supported
-    include BMP, GIF, HEIF, ICO, JPEG, PNG, WBMP, WebP. Supported encoding details
-    vary with platform.
+/** Caller data passed to RasterReleaseProc; may be nullptr. */
+using ReleaseContext = void*;
+/** Function called when SkImage no longer shares pixels. ReleaseContext is
+    provided by caller when SkImage is created, and may be nullptr.
 */
-class SK_API SkImage : public SkRefCnt {
-public:
-
-    /** Caller data passed to RasterReleaseProc; may be nullptr.
-    */
-    typedef void* ReleaseContext;
-
-    /** Creates SkImage from SkPixmap and copy of pixels. Since pixels are copied, SkPixmap
-        pixels may be modified or deleted without affecting SkImage.
-
-        SkImage is returned if SkPixmap is valid. Valid SkPixmap parameters include:
-        dimensions are greater than zero;
-        each dimension fits in 29 bits;
-        SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
-        row bytes are large enough to hold one row of pixels;
-        pixel address is not nullptr.
-
-        @param pixmap  SkImageInfo, pixel address, and row bytes
-        @return        copy of SkPixmap pixels, or nullptr
+using RasterReleaseProc = void(const void* pixels, ReleaseContext);
 
-        example: https://fiddle.skia.org/c/@Image_MakeRasterCopy
-    */
-    static sk_sp<SkImage> MakeRasterCopy(const SkPixmap& pixmap);
-
-    /** Creates SkImage from SkImageInfo, sharing pixels.
+/** Creates a CPU-backed SkImage from bitmap, sharing or copying bitmap pixels. If the bitmap
+    is marked immutable, and its pixel memory is shareable, it may be shared
+    instead of copied.
 
-        SkImage is returned if SkImageInfo is valid. Valid SkImageInfo parameters include:
-        dimensions are greater than zero;
-        each dimension fits in 29 bits;
-        SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
-        rowBytes are large enough to hold one row of pixels;
-        pixels is not nullptr, and contains enough data for SkImage.
-
-        @param info      contains width, height, SkAlphaType, SkColorType, SkColorSpace
-        @param pixels    address or pixel storage
-        @param rowBytes  size of pixel row or larger
-        @return          SkImage sharing pixels, or nullptr
-    */
-    static sk_sp<SkImage> MakeRasterData(const SkImageInfo& info, sk_sp<SkData> pixels,
-                                         size_t rowBytes);
+    SkImage is returned if bitmap is valid. Valid SkBitmap parameters include:
+    dimensions are greater than zero;
+    each dimension fits in 29 bits;
+    SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
+    row bytes are large enough to hold one row of pixels;
+    pixel address is not nullptr.
 
-    /** Function called when SkImage no longer shares pixels. ReleaseContext is
-        provided by caller when SkImage is created, and may be nullptr.
-    */
-    typedef void (*RasterReleaseProc)(const void* pixels, ReleaseContext);
-
-    /** Creates SkImage from pixmap, sharing SkPixmap pixels. Pixels must remain valid and
-        unchanged until rasterReleaseProc is called. rasterReleaseProc is passed
-        releaseContext when SkImage is deleted or no longer refers to pixmap pixels.
-
-        Pass nullptr for rasterReleaseProc to share SkPixmap without requiring a callback
-        when SkImage is released. Pass nullptr for releaseContext if rasterReleaseProc
-        does not require state.
-
-        SkImage is returned if pixmap is valid. Valid SkPixmap parameters include:
-        dimensions are greater than zero;
-        each dimension fits in 29 bits;
-        SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
-        row bytes are large enough to hold one row of pixels;
-        pixel address is not nullptr.
-
-        @param pixmap             SkImageInfo, pixel address, and row bytes
-        @param rasterReleaseProc  function called when pixels can be released; or nullptr
-        @param releaseContext     state passed to rasterReleaseProc; or nullptr
-        @return                   SkImage sharing pixmap
-    */
-    static sk_sp<SkImage> MakeFromRaster(const SkPixmap& pixmap,
-                                         RasterReleaseProc rasterReleaseProc,
-                                         ReleaseContext releaseContext);
-
-    /** Creates SkImage from bitmap, sharing or copying bitmap pixels. If the bitmap
-        is marked immutable, and its pixel memory is shareable, it may be shared
-        instead of copied.
-
-        SkImage is returned if bitmap is valid. Valid SkBitmap parameters include:
-        dimensions are greater than zero;
-        each dimension fits in 29 bits;
-        SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
-        row bytes are large enough to hold one row of pixels;
-        pixel address is not nullptr.
-
-        @param bitmap  SkImageInfo, row bytes, and pixels
-        @return        created SkImage, or nullptr
-
-        example: https://fiddle.skia.org/c/@Image_MakeFromBitmap
-    */
-    static sk_sp<SkImage> MakeFromBitmap(const SkBitmap& bitmap);
-
-    /** Creates SkImage from data returned by imageGenerator. Generated data is owned by SkImage and
-        may not be shared or accessed.
-
-        SkImage is returned if generator data is valid. Valid data parameters vary by type of data
-        and platform.
-
-        imageGenerator may wrap SkPicture data, codec data, or custom data.
-
-        @param imageGenerator  stock or custom routines to retrieve SkImage
-        @return                created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromGenerator(std::unique_ptr<SkImageGenerator> imageGenerator);
-
-    /**
-     *  Return an image backed by the encoded data, but attempt to defer decoding until the image
-     *  is actually used/drawn. This deferral allows the system to cache the result, either on the
-     *  CPU or on the GPU, depending on where the image is drawn. If memory is low, the cache may
-     *  be purged, causing the next draw of the image to have to re-decode.
-     *
-     *  If alphaType is nullopt, the image's alpha type will be chosen automatically based on the
-     *  image format. Transparent images will default to kPremul_SkAlphaType. If alphaType contains
-     *  kPremul_SkAlphaType or kUnpremul_SkAlphaType, that alpha type will be used. Forcing opaque
-     *  (passing kOpaque_SkAlphaType) is not allowed, and will return nullptr.
-     *
-     *  This is similar to DecodeTo[Raster,Texture], but this method will attempt to defer the
-     *  actual decode, while the DecodeTo... method explicitly decode and allocate the backend
-     *  when the call is made.
-     *
-     *  If the encoded format is not supported, nullptr is returned.
-     *
-     *  @param encoded  the encoded data
-     *  @return         created SkImage, or nullptr
-
-        example: https://fiddle.skia.org/c/@Image_MakeFromEncoded
-    */
-    static sk_sp<SkImage> MakeFromEncoded(sk_sp<SkData> encoded,
-                                          std::optional<SkAlphaType> alphaType = std::nullopt);
-
-    /*
-     * Experimental:
-     *   Skia                | GL_COMPRESSED_*     | MTLPixelFormat*      | VK_FORMAT_*_BLOCK
-     *  --------------------------------------------------------------------------------------
-     *   kETC2_RGB8_UNORM    | ETC1_RGB8           | ETC2_RGB8 (iOS-only) | ETC2_R8G8B8_UNORM
-     *                       | RGB8_ETC2           |                      |
-     *  --------------------------------------------------------------------------------------
-     *   kBC1_RGB8_UNORM     | RGB_S3TC_DXT1_EXT   | N/A                  | BC1_RGB_UNORM
-     *  --------------------------------------------------------------------------------------
-     *   kBC1_RGBA8_UNORM    | RGBA_S3TC_DXT1_EXT  | BC1_RGBA (macOS-only)| BC1_RGBA_UNORM
-     */
-    enum class CompressionType {
-        kNone,
-        kETC2_RGB8_UNORM, // the same as ETC1
-
-        kBC1_RGB8_UNORM,
-        kBC1_RGBA8_UNORM,
-        kLast = kBC1_RGBA8_UNORM,
-    };
+    @param bitmap  SkImageInfo, row bytes, and pixels
+    @return        created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> RasterFromBitmap(const SkBitmap& bitmap);
 
-    static constexpr int kCompressionTypeCount = static_cast<int>(CompressionType::kLast) + 1;
+/** Creates a CPU-backed SkImage from compressed data.
 
-    static const CompressionType kETC1_CompressionType = CompressionType::kETC2_RGB8_UNORM;
+    This method will decompress the compressed data and create an image wrapping
+    it. Any mipmap levels present in the compressed data are discarded.
 
-    /** Creates a CPU-backed SkImage from compressed data.
+    @param data     compressed data to store in SkImage
+    @param width    width of full SkImage
+    @param height   height of full SkImage
+    @param type     type of compression used
+    @return         created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> RasterFromCompressedTextureData(sk_sp<SkData> data,
+                                                      int width,
+                                                      int height,
+                                                      SkTextureCompressionType type);
+
+/**
+ *  Return a SkImage using the encoded data, but attempts to defer decoding until the
+ *  image is actually used/drawn. This deferral allows the system to cache the result, either on the
+ *  CPU or on the GPU, depending on where the image is drawn. If memory is low, the cache may
+ *  be purged, causing the next draw of the image to have to re-decode.
+ *
+ *  If alphaType is nullopt, the image's alpha type will be chosen automatically based on the
+ *  image format. Transparent images will default to kPremul_SkAlphaType. If alphaType contains
+ *  kPremul_SkAlphaType or kUnpremul_SkAlphaType, that alpha type will be used. Forcing opaque
+ *  (passing kOpaque_SkAlphaType) is not allowed, and will return nullptr.
+ *
+ *  If the encoded format is not supported, nullptr is returned.
+ *
+ *  @param encoded  the encoded data
+ *  @return         created SkImage, or nullptr
 
-        This method will decompress the compressed data and create an image wrapping
-        it. Any mipmap levels present in the compressed data are discarded.
+    example: https://fiddle.skia.org/c/@Image_DeferredFromEncodedData
+*/
+SK_API sk_sp<SkImage> DeferredFromEncodedData(sk_sp<SkData> encoded,
+                                              std::optional<SkAlphaType> alphaType = std::nullopt);
 
-        @param data     compressed data to store in SkImage
-        @param width    width of full SkImage
-        @param height   height of full SkImage
-        @param type     type of compression used
-        @return         created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeRasterFromCompressed(sk_sp<SkData> data,
-                                                   int width, int height,
-                                                   CompressionType type);
+/** Creates SkImage from data returned by imageGenerator. The image data will not be created
+    (on either the CPU or GPU) until the image is actually drawn.
+    Generated data is owned by SkImage and may not be shared or accessed.
 
-    enum class BitDepth {
-        kU8,  //!< uses 8-bit unsigned int per color component
-        kF16, //!< uses 16-bit float per color component
-    };
+    SkImage is returned if generator data is valid. Valid data parameters vary by type of data
+    and platform.
 
-    /** Creates SkImage from picture. Returned SkImage width and height are set by dimensions.
-        SkImage draws picture with matrix and paint, set to bitDepth and colorSpace.
+    imageGenerator may wrap SkPicture data, codec data, or custom data.
 
-        If matrix is nullptr, draws with identity SkMatrix. If paint is nullptr, draws
-        with default SkPaint. colorSpace may be nullptr.
+    @param imageGenerator  stock or custom routines to retrieve SkImage
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> DeferredFromGenerator(std::unique_ptr<SkImageGenerator> imageGenerator);
 
-        @param picture     stream of drawing commands
-        @param dimensions  width and height
-        @param matrix      SkMatrix to rotate, scale, translate, and so on; may be nullptr
-        @param paint       SkPaint to apply transparency, filtering, and so on; may be nullptr
-        @param bitDepth    8-bit integer or 16-bit float: per component
-        @param colorSpace  range of colors; may be nullptr
-        @param props       props to use when rasterizing the picture
-        @return            created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions,
-                                          const SkMatrix* matrix, const SkPaint* paint,
-                                          BitDepth bitDepth, sk_sp<SkColorSpace> colorSpace,
-                                          SkSurfaceProps props = {});
-
-#if SK_SUPPORT_GPU
-        /** Creates a GPU-backed SkImage from compressed data.
-
-        This method will return an SkImage representing the compressed data.
-        If the GPU doesn't support the specified compression method, the data
-        will be decompressed and then wrapped in a GPU-backed image.
-
-        Note: one can query the supported compression formats via
-        GrRecordingContext::compressedBackendFormat.
-
-        @param context     GPU context
-        @param data        compressed data to store in SkImage
-        @param width       width of full SkImage
-        @param height      height of full SkImage
-        @param type        type of compression used
-        @param mipmapped   does 'data' contain data for all the mipmap levels?
-        @param isProtected do the contents of 'data' require DRM protection (on Vulkan)?
-        @return            created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeTextureFromCompressed(GrDirectContext* direct,
-                                                    sk_sp<SkData> data,
-                                                    int width, int height,
-                                                    CompressionType type,
-                                                    GrMipmapped mipmapped = GrMipmapped::kNo,
-                                                    GrProtected isProtected = GrProtected::kNo);
-
-    /** User function called when supplied texture may be deleted.
-    */
-    typedef void (*TextureReleaseProc)(ReleaseContext releaseContext);
+enum class BitDepth {
+    kU8,   //!< uses 8-bit unsigned int per color component
+    kF16,  //!< uses 16-bit float per color component
+};
 
-    /** Creates SkImage from GPU texture associated with context. GPU texture must stay
-        valid and unchanged until textureReleaseProc is called. textureReleaseProc is
-        passed releaseContext when SkImage is deleted or no longer refers to texture.
+/** Creates SkImage from picture. Returned SkImage width and height are set by dimensions.
+    SkImage draws picture with matrix and paint, set to bitDepth and colorSpace.
 
-        SkImage is returned if format of backendTexture is recognized and supported.
-        Recognized formats vary by GPU back-end.
+    The Picture data is not turned into an image (CPU or GPU) until it is drawn.
 
-        @note When using a DDL recording context, textureReleaseProc will be called on the
-        GPU thread after the DDL is played back on the direct context.
+    If matrix is nullptr, draws with identity SkMatrix. If paint is nullptr, draws
+    with default SkPaint. colorSpace may be nullptr.
 
-        @param context             GPU context
-        @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 textureReleaseProc  function called when texture can be released
-        @param releaseContext      state passed to textureReleaseProc
-        @return                    created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromTexture(GrRecordingContext* context,
-                                          const GrBackendTexture& backendTexture,
-                                          GrSurfaceOrigin origin,
-                                          SkColorType colorType,
-                                          SkAlphaType alphaType,
+    @param picture     stream of drawing commands
+    @param dimensions  width and height
+    @param matrix      SkMatrix to rotate, scale, translate, and so on; may be nullptr
+    @param paint       SkPaint to apply transparency, filtering, and so on; may be nullptr
+    @param bitDepth    8-bit integer or 16-bit float: per component
+    @param colorSpace  range of colors; may be nullptr
+    @param props       props to use when rasterizing the picture
+    @return            created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> DeferredFromPicture(sk_sp<SkPicture> picture,
+                                          const SkISize& dimensions,
+                                          const SkMatrix* matrix,
+                                          const SkPaint* paint,
+                                          BitDepth bitDepth,
                                           sk_sp<SkColorSpace> colorSpace,
-                                          TextureReleaseProc textureReleaseProc = nullptr,
-                                          ReleaseContext releaseContext = nullptr);
-
-    /** Creates an SkImage from a GPU backend texture. The backend texture must stay
-        valid and unchanged until textureReleaseProc is called. The textureReleaseProc is
-        called when the SkImage is deleted or no longer refers to the texture and will be
-        passed the releaseContext.
-
-        An SkImage is returned if the format of backendTexture is recognized and supported.
-        Recognized formats vary by GPU back-end.
-
-        @note When using a DDL recording context, textureReleaseProc will be called on the
-        GPU thread after the DDL is played back on the direct context.
-
-        @param context             the GPU context
-        @param backendTexture      a texture already allocated by the GPU
-        @param alphaType           This characterizes the nature of the alpha values in the
-                                   backend texture. For opaque compressed formats (e.g., ETC1)
-                                   this should usually be set to kOpaque_SkAlphaType.
-        @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 textureReleaseProc  function called when the backend texture can be released
-        @param releaseContext      state passed to textureReleaseProc
-        @return                    created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromCompressedTexture(GrRecordingContext* context,
-                                                    const GrBackendTexture& backendTexture,
-                                                    GrSurfaceOrigin origin,
-                                                    SkAlphaType alphaType,
-                                                    sk_sp<SkColorSpace> colorSpace,
-                                                    TextureReleaseProc textureReleaseProc = nullptr,
-                                                    ReleaseContext releaseContext = nullptr);
-
-    /** Creates SkImage from pixmap. SkImage is uploaded to GPU back-end using context.
-
-        Created SkImage is available to other GPU contexts, and is available across thread
-        boundaries. All contexts must be in the same GPU share group, or otherwise
-        share resources.
-
-        When SkImage is no longer referenced, context releases texture memory
-        asynchronously.
-
-        GrBackendTexture created from pixmap is uploaded to match SkSurface created with
-        dstColorSpace. SkColorSpace of SkImage is determined by pixmap.colorSpace().
-
-        SkImage is returned referring to GPU back-end if context is not nullptr,
-        format of data is recognized and supported, and if context supports moving
-        resources between contexts. Otherwise, pixmap pixel data is copied and SkImage
-        as returned in raster format if possible; nullptr may be returned.
-        Recognized GPU formats vary by platform and GPU back-end.
-
-        @param context                GPU context
-        @param pixmap                 SkImageInfo, pixel address, and row bytes
-        @param buildMips              create SkImage as mip map if true
-        @param dstColorSpace          range of colors of matching SkSurface on GPU
-        @param limitToMaxTextureSize  downscale image to GPU maximum texture size, if necessary
-        @return                       created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeCrossContextFromPixmap(GrDirectContext* context,
-                                                     const SkPixmap& pixmap,
-                                                     bool buildMips,
-                                                     bool limitToMaxTextureSize = false);
-
-    /** Creates SkImage from backendTexture associated with context. backendTexture and
-        returned SkImage are managed internally, and are released when no longer needed.
-
-        SkImage is returned if format of backendTexture is recognized and supported.
-        Recognized formats vary by GPU back-end.
-
-        @param context         GPU context
-        @param backendTexture  texture residing on GPU
-        @param textureOrigin   origin of backendTexture
-        @param colorType       color type of the resulting image
-        @param alphaType       alpha type of the resulting image
-        @param colorSpace      range of colors; may be nullptr
-        @return                created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
-                                                 const GrBackendTexture& backendTexture,
-                                                 GrSurfaceOrigin textureOrigin,
-                                                 SkColorType colorType);
-    static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
-                                                 const GrBackendTexture& backendTexture,
-                                                 GrSurfaceOrigin textureOrigin,
-                                                 SkColorType colorType,
-                                                 SkAlphaType alphaType);
-    static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
-                                                 const GrBackendTexture& backendTexture,
-                                                 GrSurfaceOrigin textureOrigin,
-                                                 SkColorType colorType,
-                                                 SkAlphaType alphaType,
-                                                 sk_sp<SkColorSpace> colorSpace);
-
-    /** Creates an SkImage from YUV[A] planar textures. This requires that the textures stay valid
-        for the lifetime of the image. The ReleaseContext can be used to know when it is safe to
-        either delete or overwrite the textures. If ReleaseProc is provided it is also called before
-        return on failure.
-
-        @param context            GPU context
-        @param yuvaTextures       A set of textures containing YUVA data and a description of the
-                                  data and transformation to RGBA.
-        @param imageColorSpace    range of colors of the resulting image after conversion to RGB;
-                                  may be nullptr
-        @param textureReleaseProc called when the backend textures can be released
-        @param releaseContext     state passed to textureReleaseProc
-        @return                   created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromYUVATextures(GrRecordingContext* context,
-                                               const GrYUVABackendTextures& yuvaTextures,
-                                               sk_sp<SkColorSpace> imageColorSpace = nullptr,
-                                               TextureReleaseProc textureReleaseProc = nullptr,
-                                               ReleaseContext releaseContext = nullptr);
-
-    /** Creates SkImage from SkYUVAPixmaps.
-
-        The image will remain planar with each plane converted to a texture using the passed
-        GrRecordingContext.
-
-        SkYUVAPixmaps has a SkYUVAInfo which specifies the transformation from YUV to RGB.
-        The SkColorSpace of the resulting RGB values is specified by imageColorSpace. This will
-        be the SkColorSpace reported by the image and when drawn the RGB values will be converted
-        from this space into the destination space (if the destination is tagged).
-
-        Currently, this is only supported using the GPU backend and will fail if context is nullptr.
+                                          SkSurfaceProps props);
+SK_API sk_sp<SkImage> DeferredFromPicture(sk_sp<SkPicture> picture,
+                                          const SkISize& dimensions,
+                                          const SkMatrix* matrix,
+                                          const SkPaint* paint,
+                                          BitDepth bitDepth,
+                                          sk_sp<SkColorSpace> colorSpace);
+
+/** Creates a CPU-backed SkImage from pixmap, copying the pixel data.
+    As a result, pixmap pixels may be modified or deleted without affecting SkImage.
+
+    SkImage is returned if SkPixmap is valid. Valid SkPixmap parameters include:
+    dimensions are greater than zero;
+    each dimension fits in 29 bits;
+    SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
+    row bytes are large enough to hold one row of pixels;
+    pixel address is not nullptr.
+
+    @param pixmap  SkImageInfo, pixel address, and row bytes
+    @return        copy of SkPixmap pixels, or nullptr
+
+    example: https://fiddle.skia.org/c/@Image_RasterFromPixmapCopy
+*/
+SK_API sk_sp<SkImage> RasterFromPixmapCopy(const SkPixmap& pixmap);
+
+/** Creates CPU-backed SkImage from pixmap, sharing SkPixmap pixels. Pixels must remain valid and
+    unchanged until rasterReleaseProc is called. rasterReleaseProc is passed
+    releaseContext when SkImage is deleted or no longer refers to pixmap pixels.
+
+    Pass nullptr for rasterReleaseProc to share SkPixmap without requiring a callback
+    when SkImage is released. Pass nullptr for releaseContext if rasterReleaseProc
+    does not require state.
+
+    SkImage is returned if pixmap is valid. Valid SkPixmap parameters include:
+    dimensions are greater than zero;
+    each dimension fits in 29 bits;
+    SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
+    row bytes are large enough to hold one row of pixels;
+    pixel address is not nullptr.
+
+    @param pixmap             SkImageInfo, pixel address, and row bytes
+    @param rasterReleaseProc  function called when pixels can be released; or nullptr
+    @param releaseContext     state passed to rasterReleaseProc; or nullptr
+    @return                   SkImage sharing pixmap
+*/
+SK_API sk_sp<SkImage> RasterFromPixmap(const SkPixmap& pixmap,
+                                       RasterReleaseProc rasterReleaseProc,
+                                       ReleaseContext releaseContext);
+
+/** Creates CPU-backed SkImage from pixel data described by info.
+    The pixels data will *not* be copied.
+
+    SkImage is returned if SkImageInfo is valid. Valid SkImageInfo parameters include:
+    dimensions are greater than zero;
+    each dimension fits in 29 bits;
+    SkColorType and SkAlphaType are valid, and SkColorType is not kUnknown_SkColorType;
+    rowBytes are large enough to hold one row of pixels;
+    pixels is not nullptr, and contains enough data for SkImage.
+
+    @param info      contains width, height, SkAlphaType, SkColorType, SkColorSpace
+    @param pixels    address or pixel storage
+    @param rowBytes  size of pixel row or larger
+    @return          SkImage sharing pixels, or nullptr
+*/
+SK_API sk_sp<SkImage> RasterFromData(const SkImageInfo& info,
+                                     sk_sp<SkData> pixels,
+                                     size_t rowBytes);
 
-        SkYUVAPixmaps does not need to remain valid after this returns.
+}  // namespace SkImages
 
-        @param context                GPU context
-        @param pixmaps                The planes as pixmaps with supported SkYUVAInfo that
-                                      specifies conversion to RGB.
-        @param buildMips              create internal YUVA textures as mip map if kYes. This is
-                                      silently ignored if the context does not support mip maps.
-        @param limitToMaxTextureSize  downscale image to GPU maximum texture size, if necessary
-        @param imageColorSpace        range of colors of the resulting image; may be nullptr
-        @return                       created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromYUVAPixmaps(GrRecordingContext* context,
-                                              const SkYUVAPixmaps& pixmaps,
-                                              GrMipmapped buildMips = GrMipmapped::kNo,
-                                              bool limitToMaxTextureSize = false,
-                                              sk_sp<SkColorSpace> imageColorSpace = nullptr);
-
-    using PromiseImageTextureContext = void*;
-    using PromiseImageTextureFulfillProc =
-            sk_sp<SkPromiseImageTexture> (*)(PromiseImageTextureContext);
-    using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
-
-    /** Create a new SkImage that is very similar to an SkImage created by MakeFromTexture. The
-        difference is that the caller need not have created the texture nor populated it with the
-        image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
-        image does not require access to the backend API or GrDirectContext. Instead of passing a
-        GrBackendTexture the client supplies a description of the texture consisting of
-        GrBackendFormat, width, height, and GrMipmapped state. The resulting SkImage can be drawn
-        to a SkDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
-
-        When the actual texture is required to perform a backend API draw, textureFulfillProc will
-        be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
-        those set during the SkImage creation, and it must refer to a valid existing texture in the
-        backend API context/device, and be populated with the image pixel data. The texture cannot
-        be deleted until textureReleaseProc is called.
-
-        There is at most one call to each of textureFulfillProc and textureReleaseProc.
-        textureReleaseProc is always called even if image creation fails or if the
-        image is never fulfilled (e.g. it is never drawn or all draws are clipped out)
-
-        @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
-        @param backendFormat       format of promised gpu texture
-        @param dimensions          width & height of promised gpu texture
-        @param mipmapped           mip mapped state of promised gpu texture
-        @param origin              surface origin of promised gpu texture
-        @param colorType           color type of promised gpu texture
-        @param alphaType           alpha type of promised gpu texture
-        @param colorSpace          range of colors; may be nullptr
-        @param textureFulfillProc  function called to get actual gpu texture
-        @param textureReleaseProc  function called when texture can be deleted
-        @param textureContext      state passed to textureFulfillProc and textureReleaseProc
-        @return                    created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakePromiseTexture(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
-                                             const GrBackendFormat& backendFormat,
-                                             SkISize dimensions,
-                                             GrMipmapped mipmapped,
-                                             GrSurfaceOrigin origin,
-                                             SkColorType colorType,
-                                             SkAlphaType alphaType,
-                                             sk_sp<SkColorSpace> colorSpace,
-                                             PromiseImageTextureFulfillProc textureFulfillProc,
-                                             PromiseImageTextureReleaseProc textureReleaseProc,
-                                             PromiseImageTextureContext textureContext);
-
-    /** This entry point operates like 'MakePromiseTexture' but it is used to construct a SkImage
-        from YUV[A] data. The source data may be planar (i.e. spread across multiple textures). In
-        the extreme Y, U, V, and A are all in different planes and thus the image is specified by
-        four textures. 'backendTextureInfo' describes the planar arrangement, texture formats,
-        conversion to RGB, and origin of the textures. Separate 'textureFulfillProc' and
-        'textureReleaseProc' calls are made for each texture. Each texture has its own
-        PromiseImageTextureContext. If 'backendTextureInfo' is not valid then no release proc
-        calls are made. Otherwise, the calls will be made even on failure. 'textureContexts' has one
-        entry for each of the up to four textures, as indicated by 'backendTextureInfo'.
-
-        Currently the mip mapped property of 'backendTextureInfo' is ignored. However, in the
-        near future it will be required that if it is kYes then textureFulfillProc must return
-        a mip mapped texture for each plane in order to successfully draw the image.
-
-        @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
-        @param backendTextureInfo  info about the promised yuva gpu texture
-        @param imageColorSpace     range of colors; may be nullptr
-        @param textureFulfillProc  function called to get actual gpu texture
-        @param textureReleaseProc  function called when texture can be deleted
-        @param textureContexts     state passed to textureFulfillProc and textureReleaseProc
-        @return                    created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakePromiseYUVATexture(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
-                                                 const GrYUVABackendTextureInfo& backendTextureInfo,
-                                                 sk_sp<SkColorSpace> imageColorSpace,
-                                                 PromiseImageTextureFulfillProc textureFulfillProc,
-                                                 PromiseImageTextureReleaseProc textureReleaseProc,
-                                                 PromiseImageTextureContext textureContexts[]);
+/** \class SkImage
+    SkImage describes a two dimensional array of pixels to draw. The pixels may be
+    decoded in a raster bitmap, encoded in a SkPicture or compressed data stream,
+    or located in GPU memory as a GPU texture.
 
-#endif // SK_SUPPORT_GPU
+    SkImage cannot be modified after it is created. SkImage may allocate additional
+    storage as needed; for instance, an encoded SkImage may decode when drawn.
 
-#if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
-    /** (See Skia bug 7447)
-        Creates SkImage from Android hardware buffer.
-        Returned SkImage takes a reference on the buffer.
+    SkImage width and height are greater than zero. Creating an SkImage with zero width
+    or height returns SkImage equal to nullptr.
 
-        Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    SkImage may be created from SkBitmap, SkPixmap, SkSurface, SkPicture, encoded streams,
+    GPU texture, YUV_ColorSpace data, or hardware buffer. Encoded streams supported
+    include BMP, GIF, HEIF, ICO, JPEG, PNG, WBMP, WebP. Supported encoding details
+    vary with platform.
 
-        @param hardwareBuffer  AHardwareBuffer Android hardware buffer
-        @param colorSpace      range of colors; may be nullptr
-        @return                created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromAHardwareBuffer(
-            AHardwareBuffer* hardwareBuffer,
-            SkAlphaType alphaType = kPremul_SkAlphaType,
-            sk_sp<SkColorSpace> colorSpace = nullptr,
-            GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
-
-    /** Creates SkImage from Android hardware buffer and uploads the data from the SkPixmap to it.
-        Returned SkImage takes a reference on the buffer.
-
-        Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
-
-        @param context         GPU context
-        @param pixmap          SkPixmap that contains data to be uploaded to the AHardwareBuffer
-        @param hardwareBuffer  AHardwareBuffer Android hardware buffer
-        @param surfaceOrigin   surface origin for resulting image
-        @return                created SkImage, or nullptr
-    */
-    static sk_sp<SkImage> MakeFromAHardwareBufferWithData(
-            GrDirectContext* context,
-            const SkPixmap& pixmap,
-            AHardwareBuffer* hardwareBuffer,
-            GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
-#endif
+    See SkImages namespace for the static factory methods to make SkImages.
 
+    Clients should *not* subclass SkImage as there is a lot of internal machinery that is
+    not publicly accessible.
+*/
+class SK_API SkImage : public SkRefCnt {
+public:
     /** Returns a SkImageInfo describing the width, height, color type, alpha type, and color space
         of the SkImage.
 
@@ -691,18 +362,12 @@ public:
      */
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions&,
                                const SkMatrix* localMatrix = nullptr) const;
-
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions& sampling,
-                               const SkMatrix& lm) const {
-        return this->makeShader(tmx, tmy, sampling, &lm);
-    }
-    sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const {
-        return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, &lm);
-    }
+                               const SkMatrix& lm) const;
+    /** Defaults to clamp in both X and Y. */
+    sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const;
     sk_sp<SkShader> makeShader(const SkSamplingOptions& sampling,
-                               const SkMatrix* lm = nullptr) const {
-        return this->makeShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, lm);
-    }
+                               const SkMatrix* lm = nullptr) const;
 
     /**
      *  makeRawShader functions like makeShader, but for images that contain non-color data.
@@ -719,20 +384,12 @@ public:
      */
     sk_sp<SkShader> makeRawShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions&,
                                   const SkMatrix* localMatrix = nullptr) const;
-
     sk_sp<SkShader> makeRawShader(SkTileMode tmx, SkTileMode tmy, const SkSamplingOptions& sampling,
-                                  const SkMatrix& lm) const {
-        return this->makeRawShader(tmx, tmy, sampling, &lm);
-    }
-    sk_sp<SkShader> makeRawShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const {
-        return this->makeRawShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, &lm);
-    }
+                                  const SkMatrix& lm) const;
+    /** Defaults to clamp in both X and Y. */
+    sk_sp<SkShader> makeRawShader(const SkSamplingOptions& sampling, const SkMatrix& lm) const;
     sk_sp<SkShader> makeRawShader(const SkSamplingOptions& sampling,
-                                  const SkMatrix* lm = nullptr) const {
-        return this->makeRawShader(SkTileMode::kClamp, SkTileMode::kClamp, sampling, lm);
-    }
-
-    using CubicResampler = SkCubicResampler;
+                                  const SkMatrix* lm = nullptr) const;
 
     /** Copies SkImage pixel address, row bytes, and SkImageInfo to pixmap, if address
         is available, and returns true. If pixel address is not available, return
@@ -752,12 +409,12 @@ public:
 
         example: https://fiddle.skia.org/c/@Image_isTextureBacked
     */
-    bool isTextureBacked() const;
+    virtual bool isTextureBacked() const = 0;
 
     /** Returns an approximation of the amount of texture memory used by the image. Returns
         zero if the image is not texture backed or if the texture has an external format.
      */
-    size_t textureSize() const;
+    virtual size_t textureSize() const = 0;
 
     /** Returns true if SkImage can be drawn on either raster surface or GPU surface.
         If context is nullptr, tests if SkImage draws on raster surface;
@@ -772,43 +429,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Image_isValid
     */
-    bool isValid(GrRecordingContext* context) const;
-
-#if SK_SUPPORT_GPU
-    /** Flushes any pending uses of texture-backed images in the GPU backend. If the image is not
-        texture-backed (including promise texture images) or if the GrDirectContext does not
-        have the same context ID as the context backing the image then this is a no-op.
-
-        If the image was not used in any non-culled draws in the current queue of work for the
-        passed GrDirectContext then this is a no-op unless the GrFlushInfo contains semaphores or
-        a finish proc. Those are respected even when the image has not been used.
-
-        @param context  the context on which to flush pending usages of the image.
-        @param info     flush options
-     */
-    GrSemaphoresSubmitted flush(GrDirectContext* context, const GrFlushInfo& flushInfo) const;
-
-    void flush(GrDirectContext* context) const { this->flush(context, {}); }
-
-    /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
-        GPU.
-    */
-    void flushAndSubmit(GrDirectContext*) const;
-
-    /** Retrieves the back-end texture. If SkImage has no back-end texture, an invalid
-        object is returned. Call GrBackendTexture::isValid to determine if the result
-        is valid.
-
-        If flushPendingGrContextIO is true, completes deferred I/O operations.
-
-        If origin in not nullptr, copies location of content drawn into SkImage.
-
-        @param flushPendingGrContextIO  flag to flush outstanding requests
-        @return                         back-end API texture handle; invalid on failure
-    */
-    GrBackendTexture getBackendTexture(bool flushPendingGrContextIO,
-                                       GrSurfaceOrigin* origin = nullptr) const;
-#endif // SK_SUPPORT_GPU
+    virtual bool isValid(GrRecordingContext* context) const = 0;
 
     /** \enum SkImage::CachingHint
         CachingHint selects whether Skia may internally cache SkBitmap generated by
@@ -941,40 +562,11 @@ public:
 
     enum class RescaleMode {
         kNearest,
+        kLinear,
         kRepeatedLinear,
         kRepeatedCubic,
     };
 
-    /** Makes image pixel data available to caller, possibly asynchronously.
-
-        Currently asynchronous reads are only supported on the GPU backend and only when the
-        underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
-        other cases this operates synchronously.
-
-        Data is read from the source sub-rectangle, then converted to the color space, color type,
-        and alpha type of 'info'. 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. For a GPU image this flushes work but a submit must occur to
-        guarantee a finite time before the callback is called.
-
-        The data is valid for the lifetime of AsyncReadResult with the exception that if the SkImage
-        is GPU-backed the data is immediately invalidated if the context is abandoned or
-        destroyed.
-
-        @param info            info of the requested pixels
-        @param srcRect         subrectangle of image to read
-        @param callback        function to call with result of the read
-        @param context         passed to callback
-    */
-    void asyncReadPixels(const SkImageInfo& info,
-                         const SkIRect& srcRect,
-                         ReadPixelsCallback callback,
-                         ReadPixelsContext context) const;
-
     /** Makes image pixel data available to caller, possibly asynchronously. It can also rescale
         the image pixels.
 
@@ -1071,44 +663,6 @@ public:
     bool scalePixels(const SkPixmap& dst, const SkSamplingOptions&,
                      CachingHint cachingHint = kAllow_CachingHint) const;
 
-    /** Encodes SkImage pixels, returning result as SkData.
-
-        Returns nullptr if encoding fails, or if encodedImageFormat is not supported.
-
-        SkImage encoding in a format requires both building with one or more of:
-        SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP; and platform support
-        for the encoded format.
-
-        If SK_BUILD_FOR_MAC or SK_BUILD_FOR_IOS is defined, encodedImageFormat can
-        additionally be one of: SkEncodedImageFormat::kICO, SkEncodedImageFormat::kBMP,
-        SkEncodedImageFormat::kGIF.
-
-        quality is a platform and format specific metric trading off size and encoding
-        error. When used, quality equaling 100 encodes with the least error. quality may
-        be ignored by the encoder.
-
-        @param encodedImageFormat  one of: SkEncodedImageFormat::kJPEG, SkEncodedImageFormat::kPNG,
-                                   SkEncodedImageFormat::kWEBP
-        @param quality             encoder specific metric with 100 equaling best
-        @return                    encoded SkImage, or nullptr
-
-        example: https://fiddle.skia.org/c/@Image_encodeToData
-    */
-    sk_sp<SkData> encodeToData(SkEncodedImageFormat encodedImageFormat, int quality) const;
-
-    /** Encodes SkImage pixels, returning result as SkData. Returns existing encoded data
-        if present; otherwise, SkImage is encoded with SkEncodedImageFormat::kPNG. Skia
-        must be built with SK_ENCODE_PNG to encode SkImage.
-
-        Returns nullptr if existing encoded data is missing or invalid, and
-        encoding fails.
-
-        @return  encoded SkImage, or nullptr
-
-        example: https://fiddle.skia.org/c/@Image_encodeToData_2
-    */
-    sk_sp<SkData> encodeToData() const;
-
     /** Returns encoded SkImage pixels as SkData, if SkImage was created from supported
         encoded stream format. Platform support for formats vary and may require building
         with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP.
@@ -1151,33 +705,79 @@ public:
      */
     sk_sp<SkImage> withDefaultMipmaps() const;
 
-#if SK_SUPPORT_GPU
-    /** Returns SkImage backed by GPU texture associated with context. Returned SkImage is
-        compatible with SkSurface created with dstColorSpace. The returned SkImage respects
-        mipmapped setting; if mipmapped equals GrMipmapped::kYes, the backing texture
-        allocates mip map levels.
-
-        The mipmapped parameter is effectively treated as kNo if MIP maps are not supported by the
-        GPU.
-
-        Returns original SkImage if the image is already texture-backed, the context matches, and
-        mipmapped is compatible with the backing GPU texture. SkBudgeted is ignored in this case.
-
-        Returns nullptr if context is nullptr, or if SkImage was created with another
-        GrDirectContext.
+#if defined(SK_GANESH) || defined(SK_GRAPHITE)
+    using ReleaseContext = SkImages::ReleaseContext;
+    using TextureReleaseProc = void (*)(ReleaseContext);
+#endif
 
-        @param GrDirectContext the GrDirectContext in play, if it exists
-        @param GrMipmapped     whether created SkImage texture must allocate mip map levels
-        @param SkBudgeted      whether to count a newly created texture for the returned image
-                               counts against the context's budget.
-        @return                created SkImage, or nullptr
+#if defined(SK_GRAPHITE)
+    // Passed to both fulfill and imageRelease
+    using GraphitePromiseImageContext = void*;
+    // Returned from fulfill and passed into textureRelease
+    using GraphitePromiseTextureReleaseContext = void*;
+
+    using GraphitePromiseImageFulfillProc =
+            std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext>
+            (*)(GraphitePromiseImageContext);
+    using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
+    using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);
+
+    /** Create a new SkImage that is very similar to an SkImage created by
+        MakeGraphiteFromBackendTexture. The difference is that the caller need not have created the
+        backend texture nor populated it with data when creating the image. Instead of passing a
+        BackendTexture to the factory the client supplies a description of the texture consisting
+        of dimensions, TextureInfo, SkColorInfo and Volatility.
+
+        In general, 'fulfill' must return a BackendTexture that matches the properties
+        provided at SkImage creation time. The BackendTexture must refer to a valid existing
+        texture in the backend API context/device, and already be populated with data.
+        The texture cannot be deleted until 'textureRelease' is called. 'textureRelease' will
+        be called with the textureReleaseContext returned by 'fulfill'.
+
+        Wrt when and how often the fulfill, imageRelease, and textureRelease callbacks will
+        be called:
+
+        For non-volatile promise images, 'fulfill' will be called at Context::insertRecording
+        time. Regardless of whether 'fulfill' succeeded or failed, 'imageRelease' will always be
+        called only once - when Skia will no longer try calling 'fulfill' to get a backend
+        texture. If 'fulfill' failed (i.e., it didn't return a valid backend texture) then
+        'textureRelease' will never be called. If 'fulfill' was successful then
+        'textureRelease' will be called only once when the GPU is done with the contents of the
+        promise image. This will usually occur during a Context::submit call but it could occur
+        earlier due to error conditions. 'fulfill' can be called multiple times if the promise
+        image is used in multiple recordings. If 'fulfill' fails, the insertRecording itself will
+        fail. Subsequent insertRecording calls (with Recordings that use the promise image) will
+        keep calling 'fulfill' until it succeeds.
+
+        For volatile promise images, 'fulfill' will be called each time the Recording is inserted
+        into a Context. Regardless of whether 'fulfill' succeeded or failed, 'imageRelease'
+        will always be called only once just like the non-volatile case. If 'fulfill' fails at
+        insertRecording-time, 'textureRelease' will never be called. If 'fulfill' was successful
+        then a 'textureRelease' matching that 'fulfill' will be called when the GPU is done with
+        the contents of the promise image. This will usually occur during a Context::submit call
+        but it could occur earlier due to error conditions.
+
+        @param recorder       the recorder that will capture the commands creating the image
+        @param dimensions     width & height of promised gpu texture
+        @param textureInfo    structural information for the promised gpu texture
+        @param colorInfo      color type, alpha type and colorSpace information for the image
+        @param isVolatile     volatility of the promise image
+        @param fulfill        function called to get the actual backend texture
+        @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 fulfill and imageRelease
+        @return               created SkImage, or nullptr
     */
-    sk_sp<SkImage> makeTextureImage(GrDirectContext*,
-                                    GrMipmapped = GrMipmapped::kNo,
-                                    SkBudgeted = SkBudgeted::kYes) const;
-#endif
+    static sk_sp<SkImage> MakeGraphitePromiseTexture(skgpu::graphite::Recorder*,
+                                                     SkISize dimensions,
+                                                     const skgpu::graphite::TextureInfo&,
+                                                     const SkColorInfo&,
+                                                     skgpu::graphite::Volatile,
+                                                     GraphitePromiseImageFulfillProc,
+                                                     GraphitePromiseImageReleaseProc,
+                                                     GraphitePromiseTextureReleaseProc,
+                                                     GraphitePromiseImageContext);
 
-#ifdef SK_GRAPHITE_ENABLED
     /** Creates an SkImage from a GPU texture associated with the recorder.
 
         SkImage is returned if the format of backendTexture is recognized and supported.
@@ -1198,12 +798,60 @@ public:
                                                          const skgpu::graphite::BackendTexture&,
                                                          SkColorType colorType,
                                                          SkAlphaType alphaType,
-                                                         sk_sp<SkColorSpace> colorSpace);
+                                                         sk_sp<SkColorSpace> colorSpace,
+                                                         TextureReleaseProc = nullptr,
+                                                         ReleaseContext = nullptr);
+
+    /** Creates an SkImage from YUV[A] planar textures associated with the recorder.
+         @param recorder            The recorder.
+         @param yuvaBackendTextures A set of textures containing YUVA data and a description of the
+                                    data and transformation to RGBA.
+         @param imageColorSpace     range of colors of the resulting image after conversion to RGB;
+                                    may be nullptr
+         @param TextureReleaseProc  called when the backend textures can be released
+         @param ReleaseContext      state passed to TextureReleaseProc
+         @return                    created SkImage, or nullptr
+     */
+    static sk_sp<SkImage> MakeGraphiteFromYUVABackendTextures(
+            skgpu::graphite::Recorder* recorder,
+            const skgpu::graphite::YUVABackendTextures& yuvaBackendTextures,
+            sk_sp<SkColorSpace> imageColorSpace,
+            TextureReleaseProc = nullptr,
+            ReleaseContext = nullptr);
 
     struct RequiredImageProperties {
-        skgpu::graphite::Mipmapped fMipmapped;
+        skgpu::Mipmapped fMipmapped;
     };
 
+    /** Creates SkImage from SkYUVAPixmaps.
+
+        The image will remain planar with each plane converted to a texture using the passed
+        Recorder.
+
+        SkYUVAPixmaps has a SkYUVAInfo which specifies the transformation from YUV to RGB.
+        The SkColorSpace of the resulting RGB values is specified by imgColorSpace. This will
+        be the SkColorSpace reported by the image and when drawn the RGB values will be converted
+        from this space into the destination space (if the destination is tagged).
+
+        This is only supported using the GPU backend and will fail if recorder is nullptr.
+
+        SkYUVAPixmaps does not need to remain valid after this returns.
+
+        @param Recorder                 The Recorder to use for storing commands
+        @param pixmaps                  The planes as pixmaps with supported SkYUVAInfo that
+                                        specifies conversion to RGB.
+        @param RequiredImageProperties  Properties the returned SkImage must possess (e.g.,
+                                        mipmaps)
+        @param limitToMaxTextureSize    Downscale image to GPU maximum texture size, if necessary
+        @param imgColorSpace            Range of colors of the resulting image; may be nullptr
+        @return                         Created SkImage, or nullptr
+    */
+    static sk_sp<SkImage> MakeGraphiteFromYUVAPixmaps(skgpu::graphite::Recorder*,
+                                                      const SkYUVAPixmaps& pixmaps,
+                                                      RequiredImageProperties = {},
+                                                      bool limitToMaxTextureSize = false,
+                                                      sk_sp<SkColorSpace> imgColorSpace = nullptr);
+
     /** Graphite version of makeTextureImage.
 
         Returns an SkImage backed by a Graphite texture, using the provided Recorder for creation
@@ -1225,9 +873,70 @@ public:
                                         mipmaps)
         @return                         created SkImage, or nullptr
     */
-    sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
-                                    RequiredImageProperties = {}) const;
-#endif
+    virtual sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
+                                            RequiredImageProperties = {}) const = 0;
+
+    /** Returns subset of this image.
+
+        Returns nullptr if any of the following are true:
+          - Subset is empty
+          - Subset is not contained inside the image's bounds
+          - Pixels in the image could not be read or copied
+
+        If this image is texture-backed, the recorder parameter is required.
+        If the recorder parameter is provided, and the image is raster-backed, the subset will
+        be converted to texture-backed.
+
+        @param subset                   bounds of returned SkImage
+        @param recorder                 the recorder in which to create the new image
+        @param RequiredImageProperties  properties the returned SkImage must possess (e.g.,
+                                        mipmaps)
+        @return                         the subsetted image, or nullptr
+    */
+    sk_sp<SkImage> makeSubset(const SkIRect& subset,
+                              skgpu::graphite::Recorder*,
+                              RequiredImageProperties = {}) const;
+
+    /** Creates SkImage in target SkColorSpace.
+        Returns nullptr if SkImage could not be created.
+
+        Returns original SkImage if it is in target SkColorSpace.
+        Otherwise, converts pixels from SkImage SkColorSpace to target SkColorSpace.
+        If SkImage colorSpace() returns nullptr, SkImage SkColorSpace is assumed to be sRGB.
+
+        If this image is graphite-backed, the recorder parameter is required.
+
+        @param targetColorSpace         SkColorSpace describing color range of returned SkImage
+        @param recorder                 The Recorder in which to create the new image
+        @param RequiredImageProperties  properties the returned SkImage must possess (e.g.,
+                                        mipmaps)
+        @return                         created SkImage in target SkColorSpace
+    */
+    sk_sp<SkImage> makeColorSpace(sk_sp<SkColorSpace> targetColorSpace,
+                                  skgpu::graphite::Recorder*,
+                                  RequiredImageProperties = {}) const;
+
+    /** Experimental.
+        Creates SkImage in target SkColorType and SkColorSpace.
+        Returns nullptr if SkImage could not be created.
+
+        Returns original SkImage if it is in target SkColorType and SkColorSpace.
+
+        If this image is graphite-backed, the recorder parameter is required.
+
+        @param targetColorType          SkColorType of returned SkImage
+        @param targetColorSpace         SkColorSpace of returned SkImage
+        @param recorder                 The Recorder in which to create the new image
+        @param RequiredImageProperties  properties the returned SkImage must possess (e.g.,
+                                        mipmaps)
+        @return                         created SkImage in target SkColorType and SkColorSpace
+    */
+    sk_sp<SkImage> makeColorTypeAndColorSpace(SkColorType targetColorType,
+                                              sk_sp<SkColorSpace> targetColorSpace,
+                                              skgpu::graphite::Recorder*,
+                                              RequiredImageProperties = {}) const;
+
+#endif // SK_GRAPHITE
 
     /** Returns raster image or lazy image. Copies SkImage backed by GPU texture into
         CPU memory if needed. Returns original SkImage if decoded in raster bitmap,
@@ -1285,38 +994,6 @@ public:
                                   const SkIRect& clipBounds, SkIRect* outSubset,
                                   SkIPoint* offset) const;
 
-    /** Defines a callback function, taking one parameter of type GrBackendTexture with
-        no return value. Function is called when back-end texture is to be released.
-    */
-    typedef std::function<void(GrBackendTexture)> BackendTextureReleaseProc;
-
-#if SK_SUPPORT_GPU
-    /** Creates a GrBackendTexture from the provided SkImage. Returns true and
-        stores result in backendTexture and backendTextureReleaseProc if
-        texture is created; otherwise, returns false and leaves
-        backendTexture and backendTextureReleaseProc unmodified.
-
-        Call backendTextureReleaseProc after deleting backendTexture.
-        backendTextureReleaseProc cleans up auxiliary data related to returned
-        backendTexture. The caller must delete returned backendTexture after use.
-
-        If SkImage is both texture backed and singly referenced, image is returned in
-        backendTexture without conversion or making a copy. SkImage is singly referenced
-        if its was transferred solely using std::move().
-
-        If SkImage is not texture backed, returns texture with SkImage contents.
-
-        @param context                    GPU context
-        @param image                      SkImage used for texture
-        @param backendTexture             storage for back-end texture
-        @param backendTextureReleaseProc  storage for clean up function
-        @return                           true if back-end texture was created
-    */
-    static bool MakeBackendTextureFromSkImage(GrDirectContext* context,
-                                              sk_sp<SkImage> image,
-                                              GrBackendTexture* backendTexture,
-                                              BackendTextureReleaseProc* backendTextureReleaseProc);
-#endif
     /** Deprecated.
      */
     enum LegacyBitmapMode {
@@ -1393,7 +1070,8 @@ private:
     SkImage(const SkImageInfo& info, uint32_t uniqueID);
 
     friend class SkBitmap;
-    friend class SkImage_Base;
+    friend class SkImage_Base;   // for private ctor
+    friend class SkImage_Raster; // for withMipmaps
     friend class SkMipmapBuilder;
 
     SkImageInfo     fInfo;