SkImages Namespace Reference

Typedefs
using	ReleaseContext = void *
using	RasterReleaseProc = void(const void *pixels, ReleaseContext)
using	BackendTextureReleaseProc = std::function< void(GrBackendTexture)>
using	TextureReleaseProc = void(*)(ReleaseContext)
using	GraphitePromiseImageContext = void *
using	GraphitePromiseTextureFulfillContext = void *
using	GraphitePromiseTextureReleaseContext = void *
using	GraphitePromiseTextureFulfillProc = std::tuple< skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext >(*)(GraphitePromiseTextureFulfillContext)
using	GraphitePromiseImageReleaseProc = void(*)(GraphitePromiseImageContext)
using	GraphitePromiseTextureReleaseProc = void(*)(GraphitePromiseTextureReleaseContext)
using	PromiseImageTextureContext = void *
using	PromiseImageTextureFulfillProc = sk_sp< GrPromiseImageTexture >(*)(PromiseImageTextureContext)
using	PromiseImageTextureReleaseProc = void(*)(PromiseImageTextureContext)

Enumerations
enum class	BitDepth { kU8 , kF16 }
enum class	GenerateMipmapsFromBase : bool { kNo , kYes }

Functions
SK_API sk_sp< SkImage >	DeferredFromAHardwareBuffer (AHardwareBuffer *hardwareBuffer, SkAlphaType alphaType=kPremul_SkAlphaType)
SK_API sk_sp< SkImage >	DeferredFromAHardwareBuffer (AHardwareBuffer *hardwareBuffer, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace, GrSurfaceOrigin surfaceOrigin=kTopLeft_GrSurfaceOrigin)
SK_API sk_sp< SkImage >	TextureFromAHardwareBufferWithData (GrDirectContext *context, const SkPixmap &pixmap, AHardwareBuffer *hardwareBuffer, GrSurfaceOrigin surfaceOrigin=kTopLeft_GrSurfaceOrigin)
SK_API sk_sp< SkImage >	PinnableRasterFromBitmap (const SkBitmap &)
SK_API sk_sp< SkImage >	RasterFromBitmap (const SkBitmap &bitmap)
SK_API sk_sp< SkImage >	RasterFromCompressedTextureData (sk_sp< SkData > data, int width, int height, SkTextureCompressionType type)
SK_API sk_sp< SkImage >	DeferredFromEncodedData (sk_sp< SkData > encoded, std::optional< SkAlphaType > alphaType=std::nullopt)
SK_API sk_sp< SkImage >	DeferredFromGenerator (std::unique_ptr< SkImageGenerator > imageGenerator)
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, 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)
SK_API sk_sp< SkImage >	RasterFromPixmapCopy (const SkPixmap &pixmap)
SK_API sk_sp< SkImage >	RasterFromPixmap (const SkPixmap &pixmap, RasterReleaseProc rasterReleaseProc, ReleaseContext releaseContext)
SK_API sk_sp< SkImage >	RasterFromData (const SkImageInfo &info, sk_sp< SkData > pixels, size_t rowBytes)
SK_API sk_sp< SkImage >	MakeWithFilter (sk_sp< SkImage > src, const SkImageFilter *filter, const SkIRect &subset, const SkIRect &clipBounds, SkIRect *outSubset, SkIPoint *offset)
SK_API sk_sp< SkImage >	DeferredFromTextureGenerator (std::unique_ptr< GrTextureGenerator > gen)
SK_API sk_sp< SkImage >	AdoptTextureFrom (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin textureOrigin, SkColorType colorType)
SK_API sk_sp< SkImage >	AdoptTextureFrom (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin textureOrigin, SkColorType colorType, SkAlphaType alphaType)
SK_API sk_sp< SkImage >	AdoptTextureFrom (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin textureOrigin, SkColorType colorType, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace)
SK_API sk_sp< SkImage >	BorrowTextureFrom (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin origin, SkColorType colorType, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API sk_sp< SkImage >	CrossContextTextureFromPixmap (GrDirectContext *context, const SkPixmap &pixmap, bool buildMips, bool limitToMaxTextureSize=false)
SK_API sk_sp< SkImage >	TextureFromCompressedTexture (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin origin, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API sk_sp< SkImage >	TextureFromCompressedTextureData (GrDirectContext *direct, sk_sp< SkData > data, int width, int height, SkTextureCompressionType type, skgpu::Mipmapped mipmapped=skgpu::Mipmapped::kNo, GrProtected isProtected=GrProtected::kNo)
SK_API sk_sp< SkImage >	TextureFromImage (GrDirectContext *, const SkImage *, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Budgeted=skgpu::Budgeted::kYes)
sk_sp< SkImage >	TextureFromImage (GrDirectContext *ctx, const sk_sp< const SkImage > &img, skgpu::Mipmapped m=skgpu::Mipmapped::kNo, skgpu::Budgeted b=skgpu::Budgeted::kYes)
SK_API sk_sp< SkImage >	TextureFromYUVAPixmaps (GrRecordingContext *context, const SkYUVAPixmaps &pixmaps, skgpu::Mipmapped buildMips, bool limitToMaxTextureSize, sk_sp< SkColorSpace > imageColorSpace)
SK_API sk_sp< SkImage >	TextureFromYUVAPixmaps (GrRecordingContext *context, const SkYUVAPixmaps &pixmaps, skgpu::Mipmapped buildMips=skgpu::Mipmapped::kNo, bool limitToMaxTextureSize=false)
SK_API sk_sp< SkImage >	TextureFromYUVATextures (GrRecordingContext *context, const GrYUVABackendTextures &yuvaTextures, sk_sp< SkColorSpace > imageColorSpace, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API sk_sp< SkImage >	TextureFromYUVATextures (GrRecordingContext *context, const GrYUVABackendTextures &yuvaTextures)
SK_API bool	GetBackendTextureFromImage (const SkImage *img, GrBackendTexture *outTexture, bool flushPendingGrContextIO, GrSurfaceOrigin *origin=nullptr)
bool	GetBackendTextureFromImage (const sk_sp< const SkImage > &img, GrBackendTexture *outTexture, bool flushPendingGrContextIO, GrSurfaceOrigin *origin=nullptr)
SK_API bool	MakeBackendTextureFromImage (GrDirectContext *context, sk_sp< SkImage > image, GrBackendTexture *backendTexture, BackendTextureReleaseProc *backendTextureReleaseProc)
bool	GetBackendTextureFromImage (GrDirectContext *context, sk_sp< SkImage > image, GrBackendTexture *backendTexture, BackendTextureReleaseProc *backendTextureReleaseProc)
SK_API sk_sp< SkImage >	SubsetTextureFrom (GrDirectContext *context, const SkImage *img, const SkIRect &subset)
SK_API sk_sp< SkImage >	MakeWithFilter (GrRecordingContext *context, sk_sp< SkImage > src, const SkImageFilter *filter, const SkIRect &subset, const SkIRect &clipBounds, SkIRect *outSubset, SkIPoint *offset)
SK_API sk_sp< SkImage >	WrapTexture (skgpu::graphite::Recorder *, const skgpu::graphite::BackendTexture &, SkColorType colorType, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace, skgpu::Origin origin, GenerateMipmapsFromBase generateMipmapsFromBase, TextureReleaseProc=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, 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, TextureReleaseProc=nullptr, ReleaseContext=nullptr, std::string_view label={})
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)
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)
SK_API sk_sp< SkImage >	PromiseTextureFrom (skgpu::graphite::Recorder *, SkISize dimensions, const skgpu::graphite::TextureInfo &, const SkColorInfo &, skgpu::Origin origin, skgpu::graphite::Volatile, GraphitePromiseTextureFulfillProc, GraphitePromiseImageReleaseProc, GraphitePromiseTextureReleaseProc, 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, GraphitePromiseTextureFulfillProc, GraphitePromiseImageReleaseProc, GraphitePromiseTextureReleaseProc, GraphitePromiseImageContext)
SK_API sk_sp< SkImage >	PromiseTextureFromYUVA (skgpu::graphite::Recorder *, const skgpu::graphite::YUVABackendTextureInfo &, sk_sp< SkColorSpace > imageColorSpace, skgpu::graphite::Volatile, GraphitePromiseTextureFulfillProc, GraphitePromiseImageReleaseProc, GraphitePromiseTextureReleaseProc, GraphitePromiseImageContext imageContext, GraphitePromiseTextureFulfillContext planeContexts[], std::string_view label={})
SK_API sk_sp< SkImage >	TextureFromImage (skgpu::graphite::Recorder *, const SkImage *, SkImage::RequiredProperties={})
sk_sp< SkImage >	TextureFromImage (skgpu::graphite::Recorder *r, const sk_sp< const SkImage > &img, SkImage::RequiredProperties props={})
SK_API sk_sp< SkImage >	TextureFromYUVAPixmaps (skgpu::graphite::Recorder *, const SkYUVAPixmaps &pixmaps, SkImage::RequiredProperties={}, bool limitToMaxTextureSize=false, sk_sp< SkColorSpace > imgColorSpace=nullptr, std::string_view label={})
SK_API sk_sp< SkImage >	TextureFromYUVATextures (skgpu::graphite::Recorder *recorder, const skgpu::graphite::YUVABackendTextures &yuvaBackendTextures, sk_sp< SkColorSpace > imageColorSpace, TextureReleaseProc=nullptr, ReleaseContext=nullptr, std::string_view label={})
SK_API sk_sp< SkImage >	TextureFromYUVAImages (skgpu::graphite::Recorder *recorder, const SkYUVAInfo &yuvaInfo, SkSpan< const sk_sp< SkImage > > images, sk_sp< SkColorSpace > imageColorSpace)
SK_API sk_sp< SkImage >	SubsetTextureFrom (skgpu::graphite::Recorder *recorder, const SkImage *img, const SkIRect &subset, SkImage::RequiredProperties props={})
SK_API sk_sp< SkImage >	MakeWithFilter (skgpu::graphite::Recorder *recorder, sk_sp< SkImage > src, const SkImageFilter *filter, const SkIRect &subset, const SkIRect &clipBounds, SkIRect *outSubset, SkIPoint *offset)
SK_API sk_sp< SkImage >	PromiseTextureFrom (sk_sp< GrContextThreadSafeProxy > gpuContextProxy, const GrBackendFormat &backendFormat, SkISize dimensions, skgpu::Mipmapped mipmapped, GrSurfaceOrigin origin, SkColorType colorType, SkAlphaType alphaType, sk_sp< SkColorSpace > colorSpace, PromiseImageTextureFulfillProc textureFulfillProc, PromiseImageTextureReleaseProc textureReleaseProc, PromiseImageTextureContext textureContext)
SK_API sk_sp< SkImage >	PromiseTextureFromYUVA (sk_sp< GrContextThreadSafeProxy > gpuContextProxy, const GrYUVABackendTextureInfo &backendTextureInfo, sk_sp< SkColorSpace > imageColorSpace, PromiseImageTextureFulfillProc textureFulfillProc, PromiseImageTextureReleaseProc textureReleaseProc, PromiseImageTextureContext textureContexts[])
SK_API GrDirectContext *	GetContext (const SkImage *src)
GrDirectContext *	GetContext (const sk_sp< const SkImage > &src)
static sk_sp< SkImage >	new_wrapped_texture_common (GrRecordingContext *rContext, const GrBackendTexture &backendTex, GrColorType colorType, GrSurfaceOrigin origin, SkAlphaType at, sk_sp< SkColorSpace > colorSpace, GrWrapOwnership ownership, sk_sp< skgpu::RefCntedCallback > releaseHelper)
static bool	validate_backend_texture (const skgpu::graphite::Caps *caps, const skgpu::graphite::BackendTexture &texture, const SkColorInfo &info)
static sk_sp< SkImage >	generate_picture_texture (skgpu::graphite::Recorder *recorder, const SkImage_Picture *img, const SkImageInfo &info, SkImage::RequiredProperties requiredProps)
static sk_sp< SkImage >	make_texture_image_from_lazy (skgpu::graphite::Recorder *recorder, const SkImage_Lazy *img, SkImage::RequiredProperties requiredProps)

Detailed Description

All factories in this file refer to the Ganesh GPU backend when they say GPU.

These functions expose features that are only for external use in Chromium.

Typedef Documentation

BackendTextureReleaseProc

using SkImages::BackendTextureReleaseProc = typedef std::function<void(GrBackendTexture)>

Defines a callback function, taking one parameter of type GrBackendTexture with no return value. Function is called when backend texture is to be released.

Definition at line 43 of file SkImageGanesh.h.

GraphitePromiseImageContext

using SkImages::GraphitePromiseImageContext = typedef void*

Definition at line 38 of file Image.h.

GraphitePromiseImageReleaseProc

using SkImages::GraphitePromiseImageReleaseProc = typedef void (*)(GraphitePromiseImageContext)

Definition at line 48 of file Image.h.

GraphitePromiseTextureFulfillContext

using SkImages::GraphitePromiseTextureFulfillContext = typedef void*

Definition at line 41 of file Image.h.

GraphitePromiseTextureFulfillProc

using SkImages::GraphitePromiseTextureFulfillProc = typedef std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)( GraphitePromiseTextureFulfillContext)

Definition at line 45 of file Image.h.

GraphitePromiseTextureReleaseContext

using SkImages::GraphitePromiseTextureReleaseContext = typedef void*

Definition at line 43 of file Image.h.

GraphitePromiseTextureReleaseProc

using SkImages::GraphitePromiseTextureReleaseProc = typedef void (*)(GraphitePromiseTextureReleaseContext)

Definition at line 49 of file Image.h.

PromiseImageTextureContext

using SkImages::PromiseImageTextureContext = typedef void*

Definition at line 35 of file SkImageChromium.h.

PromiseImageTextureFulfillProc

using SkImages::PromiseImageTextureFulfillProc = typedef sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext)

Definition at line 36 of file SkImageChromium.h.

PromiseImageTextureReleaseProc

using SkImages::PromiseImageTextureReleaseProc = typedef void (*)(PromiseImageTextureContext)

Definition at line 37 of file SkImageChromium.h.

RasterReleaseProc

using SkImages::RasterReleaseProc = typedef void(const void* pixels, ReleaseContext)

Function called when SkImage no longer shares pixels. ReleaseContext is provided by caller when SkImage is created, and may be nullptr.

Definition at line 54 of file SkImage.h.

ReleaseContext

using SkImages::ReleaseContext = typedef void*

Caller data passed to RasterReleaseProc; may be nullptr.

Definition at line 50 of file SkImage.h.

TextureReleaseProc

typedef void(* SkImages::TextureReleaseProc)(ReleaseContext)

User function called when supplied texture may be deleted.

Definition at line 45 of file SkImageGanesh.h.

Enumeration Type Documentation

BitDepth

enum class SkImages::BitDepth

strong

Enumerator
kU8	uses 8-bit unsigned int per color component
kF16	uses 16-bit float per color component

Definition at line 125 of file SkImage.h.

                    {
    kU8,   //!< uses 8-bit unsigned int per color component
    kF16,  //!< uses 16-bit float per color component
};

GenerateMipmapsFromBase

enum class SkImages::GenerateMipmapsFromBase : bool

strong

Enumerator
kNo
kYes

Definition at line 33 of file Image.h.

: bool { kNo, kYes };

Function Documentation

AdoptTextureFrom() [1/5]

sk_sp< SkImage > SkImages::AdoptTextureFrom	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	textureOrigin,
		SkColorType	colorType
	)

Creates GPU-backed SkImage from backendTexture associated with context. Skia will assume ownership of the resource and will release it when no longer needed. A non-null SkImage is returned if format of backendTexture is recognized and supported. Recognized formats vary by GPU backend.

Parameters

context	GPU context
backendTexture	texture residing on GPU
textureOrigin	origin of backendTexture
colorType	color type of the resulting image
alphaType	alpha type of the resulting image
colorSpace	range of colors; may be nullptr

Returns

created SkImage, or nullptr

Definition at line 230 of file SkImage_GaneshFactories.cpp.

                                                       {
    return AdoptTextureFrom(
            context, backendTexture, textureOrigin, colorType, kPremul_SkAlphaType, nullptr);
}

AdoptTextureFrom() [2/5]

sk_sp< SkImage > SkImages::AdoptTextureFrom	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	textureOrigin,
		SkColorType	colorType,
		SkAlphaType	alphaType
	)

Definition at line 238 of file SkImage_GaneshFactories.cpp.

                                                       {
    return AdoptTextureFrom(context, backendTexture, textureOrigin, colorType, alphaType, nullptr);
}

AdoptTextureFrom() [3/5]

sk_sp< SkImage > SkImages::AdoptTextureFrom	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	textureOrigin,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace
	)

Definition at line 246 of file SkImage_GaneshFactories.cpp.

                                                                {
    auto dContext = GrAsDirectContext(context);
    if (!dContext) {
        // We have a DDL context and we don't support adopted textures for them.
        return nullptr;
    }
 
    const GrCaps* caps = dContext->priv().caps();
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
    if (GrColorType::kUnknown == grColorType) {
        return nullptr;
    }
 
    if (!SkImage_GaneshBase::ValidateBackendTexture(
                caps, backendTexture, grColorType, colorType, alphaType, colorSpace)) {
        return nullptr;
    }
 
    return new_wrapped_texture_common(dContext,
                                      backendTexture,
                                      grColorType,
                                      origin,
                                      alphaType,
                                      std::move(colorSpace),
                                      kAdopt_GrWrapOwnership,
                                      nullptr);
}

AdoptTextureFrom() [4/5]

sk_sp< SkImage > SkImages::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  )

inline

Definition at line 107 of file Image.h.

                                                                     {
    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, origin, trProc, ctx);
}

AdoptTextureFrom() [5/5]

sk_sp< SkImage > SkImages::AdoptTextureFrom ( skgpu::graphite::Recorder *  recorder, const skgpu::graphite::BackendTexture &  tex, SkColorType  colorType, SkAlphaType  alphaType, sk_sp< SkColorSpace >  colorSpace, TextureReleaseProc  trProc = nullptr, ReleaseContext  ctx = nullptr  )

inline

Definition at line 118 of file Image.h.

                                                                     {
    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, trProc, ctx);
}

BorrowTextureFrom()

sk_sp< SkImage > SkImages::BorrowTextureFrom	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	origin,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		TextureReleaseProc	textureReleaseProc = nullptr,
		ReleaseContext	releaseContext = nullptr
	)

Creates GPU-backed SkImage from the provided GPU texture associated with context. GPU texture must stay valid and unchanged until textureReleaseProc is called by Skia. Skia will call textureReleaseProc with the passed-in releaseContext when SkImage is deleted or no longer refers to the texture. A non-null SkImage is returned if format of backendTexture is recognized and supported. Recognized formats vary by GPU backend.

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.

Parameters

context	GPU context
backendTexture	texture residing on GPU
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()).
textureReleaseProc	function called when texture can be released
releaseContext	state passed to textureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 194 of file SkImage_GaneshFactories.cpp.

                                                                {
    auto releaseHelper = skgpu::RefCntedCallback::Make(textureReleaseProc, releaseContext);
 
    if (!context) {
        return nullptr;
    }
 
    const GrCaps* caps = context->priv().caps();
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
    if (GrColorType::kUnknown == grColorType) {
        return nullptr;
    }
 
    if (!SkImage_GaneshBase::ValidateBackendTexture(
                caps, backendTexture, grColorType, colorType, alphaType, colorSpace)) {
        return nullptr;
    }
 
    return new_wrapped_texture_common(context,
                                      backendTexture,
                                      grColorType,
                                      origin,
                                      alphaType,
                                      std::move(colorSpace),
                                      kBorrow_GrWrapOwnership,
                                      std::move(releaseHelper));
}

CrossContextTextureFromPixmap()

sk_sp< SkImage > SkImages::CrossContextTextureFromPixmap	(	GrDirectContext *	context,
		const SkPixmap &	pixmap,
		bool	buildMips,
		bool	limitToMaxTextureSize = false
	)

Creates a GPU-backed SkImage from pixmap. It is uploaded to GPU backend 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. SkColorSpace of SkImage is determined by pixmap.colorSpace(). SkImage is returned referring to GPU backend 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 backend.

Parameters

context	GPU context
pixmap	SkImageInfo, pixel address, and row bytes
buildMips	create SkImage as mip map if true
limitToMaxTextureSize	downscale image to GPU maximum texture size, if necessary

Returns

created SkImage, or nullptr

Definition at line 373 of file SkImage_GaneshFactories.cpp.

                                                                         {
    // Some backends or drivers don't support (safely) moving resources between contexts
    if (!dContext || !dContext->priv().caps()->crossContextTextureSupport()) {
        return RasterFromPixmapCopy(originalPixmap);
    }
 
    // If non-power-of-two mipmapping isn't supported, ignore the client's request
    if (!dContext->priv().caps()->mipmapSupport()) {
        buildMips = false;
    }
 
    const SkPixmap* pixmap = &originalPixmap;
    SkAutoPixmapStorage resized;
    int maxTextureSize = dContext->priv().caps()->maxTextureSize();
    int maxDim = std::max(originalPixmap.width(), originalPixmap.height());
    if (limitToMaxTextureSize && maxDim > maxTextureSize) {
        float scale = static_cast<float>(maxTextureSize) / maxDim;
        int newWidth = std::min(static_cast<int>(originalPixmap.width() * scale), maxTextureSize);
        int newHeight = std::min(static_cast<int>(originalPixmap.height() * scale), maxTextureSize);
        SkImageInfo info = originalPixmap.info().makeWH(newWidth, newHeight);
        SkSamplingOptions sampling(SkFilterMode::kLinear);
        if (!resized.tryAlloc(info) || !originalPixmap.scalePixels(resized, sampling)) {
            return nullptr;
        }
        pixmap = &resized;
    }
    // Turn the pixmap into a GrTextureProxy
    SkBitmap bmp;
    bmp.installPixels(*pixmap);
    skgpu::Mipmapped mipmapped = buildMips ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
    auto [view, ct] = GrMakeUncachedBitmapProxyView(dContext, bmp, mipmapped);
    if (!view) {
        return RasterFromPixmapCopy(*pixmap);
    }
 
    sk_sp<GrTexture> texture = sk_ref_sp(view.proxy()->peekTexture());
 
    // Flush any writes or uploads
    dContext->priv().flushSurface(view.proxy());
    GrGpu* gpu = dContext->priv().getGpu();
 
    std::unique_ptr<GrSemaphore> sema = gpu->prepareTextureForCrossContextUsage(texture.get());
 
    SkColorType skCT = GrColorTypeToSkColorType(ct);
    auto gen = GrBackendTextureImageGenerator::Make(std::move(texture),
                                                    view.origin(),
                                                    std::move(sema),
                                                    skCT,
                                                    pixmap->alphaType(),
                                                    pixmap->info().refColorSpace());
    return DeferredFromTextureGenerator(std::move(gen));
}

DeferredFromAHardwareBuffer() [1/2]

SK_API sk_sp< SkImage > SkImages::DeferredFromAHardwareBuffer	(	AHardwareBuffer *	hardwareBuffer,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		GrSurfaceOrigin	surfaceOrigin = kTopLeft_GrSurfaceOrigin
	)

DeferredFromAHardwareBuffer() [2/2]

SK_API sk_sp< SkImage > SkImages::DeferredFromAHardwareBuffer	(	AHardwareBuffer *	hardwareBuffer,
		SkAlphaType	alphaType = kPremul_SkAlphaType
	)

(See Skia bug 7447) Creates SkImage from Android hardware buffer. Returned SkImage takes a reference on the buffer. Only available on Android, when ANDROID_API is defined to be 26 or greater.

Parameters

hardwareBuffer	AHardwareBuffer Android hardware buffer
colorSpace	range of colors; may be nullptr

Returns

created SkImage, or nullptr

DeferredFromEncodedData()

sk_sp< SkImage > SkImages::DeferredFromEncodedData	(	sk_sp< SkData >	encoded,
		std::optional< SkAlphaType >	alphaType = std::nullopt
	)

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.

If possible, clients should use SkCodecs::DeferredImage instead.

Parameters

encoded

the encoded data

Returns

created SkImage, or nullptr

example: https://fiddle.skia.org/c/@Image_DeferredFromEncodedData

Definition at line 52 of file SkImageGenerator_FromEncoded.cpp.

                                                                           {
    if (nullptr == encoded || encoded->isEmpty()) {
        return nullptr;
    }
    return DeferredFromGenerator(SkImageGenerators::MakeFromEncoded(std::move(encoded), alphaType));
}

DeferredFromGenerator()

sk_sp< SkImage > SkImages::DeferredFromGenerator

(

std::unique_ptr< SkImageGenerator >

imageGenerator

)

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.

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.

Parameters

imageGenerator

stock or custom routines to retrieve SkImage

Returns

created SkImage, or nullptr

Definition at line 282 of file SkImage_Lazy.cpp.

                                                                                {
    SkImage_Lazy::Validator validator(
            SharedGenerator::Make(std::move(generator)), nullptr, nullptr);
 
    return validator ? sk_make_sp<SkImage_Lazy>(&validator) : nullptr;
}

DeferredFromPicture() [1/2]

sk_sp< SkImage > SkImages::DeferredFromPicture	(	sk_sp< SkPicture >	picture,
		const SkISize &	dimensions,
		const SkMatrix *	matrix,
		const SkPaint *	paint,
		BitDepth	bitDepth,
		sk_sp< SkColorSpace >	colorSpace
	)

Definition at line 23 of file SkImage_LazyFactories.cpp.

                                                                   {
    return SkImage_Picture::Make(std::move(picture), dimensions, matrix, paint, bitDepth,
                                 std::move(colorSpace), {});
}

DeferredFromPicture() [2/2]

sk_sp< SkImage > SkImages::DeferredFromPicture	(	sk_sp< SkPicture >	picture,
		const SkISize &	dimensions,
		const SkMatrix *	matrix,
		const SkPaint *	paint,
		BitDepth	bitDepth,
		sk_sp< SkColorSpace >	colorSpace,
		SkSurfaceProps	props
	)

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.

The Picture data is not turned into an image (CPU or GPU) until it is drawn.

If matrix is nullptr, draws with identity SkMatrix. If paint is nullptr, draws with default SkPaint. colorSpace may be nullptr.

Parameters

picture	stream of drawing commands
dimensions	width and height
matrix	SkMatrix to rotate, scale, translate, and so on; may be nullptr
paint	SkPaint to apply transparency, filtering, and so on; may be nullptr
bitDepth	8-bit integer or 16-bit float: per component
colorSpace	range of colors; may be nullptr
props	props to use when rasterizing the picture

Returns

created SkImage, or nullptr

Definition at line 33 of file SkImage_LazyFactories.cpp.

                                                         {
    return SkImage_Picture::Make(std::move(picture), dimensions, matrix, paint, bitDepth,
                                 std::move(colorSpace), props);
}

DeferredFromTextureGenerator()

sk_sp< SkImage > SkImages::DeferredFromTextureGenerator

(

std::unique_ptr< GrTextureGenerator >

gen

)

Like SkImages::DeferredFromGenerator except allows for the use of GrTextureGenerator.

Parameters

gen	producer of textures

Returns

created SkImage, or nullptr

Definition at line 62 of file SkImage_LazyTexture.cpp.

                                                                                         {
    SkImage_Lazy::Validator validator(
            SharedGenerator::Make(std::move(generator)), nullptr, nullptr);
 
    return validator ? sk_make_sp<SkImage_LazyTexture>(&validator) : nullptr;
}

generate_picture_texture()

static sk_sp< SkImage > SkImages::generate_picture_texture ( skgpu::graphite::Recorder *  recorder, const SkImage_Picture *  img, const SkImageInfo &  info, SkImage::RequiredProperties  requiredProps  )

static

Definition at line 318 of file ImageFactories.cpp.

                                                                                        {
    auto mm = requiredProps.fMipmapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
    // Use a non-budgeted surface since the image wrapping the surface's texture will be owned by
    // the client.
    sk_sp<Surface> surface = Surface::Make(recorder,
                                           info,
                                           "LazySkImagePictureTexture",
                                           skgpu::Budgeted::kNo,
                                           mm,
                                           SkBackingFit::kExact,
                                           img->props());
 
    if (!surface) {
        SKGPU_LOG_E("Failed to create Surface");
        return nullptr;
    }
 
    img->replay(surface->getCanvas());
    // If the surface was created with mipmaps, they will be automatically generated when flushing
    // the tasks when 'surface' goes out of scope.
    return surface->asImage();
}

GetBackendTextureFromImage() [1/3]

bool SkImages::GetBackendTextureFromImage ( const sk_sp< const SkImage > &  img, GrBackendTexture *  outTexture, bool  flushPendingGrContextIO, GrSurfaceOrigin *  origin = nullptr  )

inline

Definition at line 279 of file SkImageGanesh.h.

                                                                          {
    return GetBackendTextureFromImage(img.get(), outTexture, flushPendingGrContextIO, origin);
}

GetBackendTextureFromImage() [2/3]

bool SkImages::GetBackendTextureFromImage	(	const SkImage *	img,
		GrBackendTexture *	outTexture,
		bool	flushPendingGrContextIO,
		GrSurfaceOrigin *	origin = nullptr
	)

Retrieves the existing backend texture. If SkImage is not a Ganesh-backend texture image or otherwise does not have such a texture, false is returned. Otherwise, outTexture will be set to the image's texture.

If flushPendingGrContextIO is true, completes deferred I/O operations. If origin in not nullptr, copies location of content drawn into SkImage.

Parameters

outTexture	Will be set to the underlying texture of the image if non-null.
flushPendingGrContextIO	flag to flush outstanding requests
origin	Will be set to the origin orientation of the image if non-null.

Returns

false if a Ganesh backend texture cannot be retrieved.

Definition at line 112 of file SkImage_GaneshFactories.cpp.

                                                         {
    if (!img) {
        return false;
    }
    auto ib = as_IB(img);
    if (ib->type() != SkImage_Base::Type::kGanesh) {
        return false;
    }
    auto ig = static_cast<const SkImage_Ganesh*>(img);
    return ig->getExistingBackendTexture(outTexture, flushPendingGrContextIO, origin);
}

GetBackendTextureFromImage() [3/3]

bool SkImages::GetBackendTextureFromImage ( GrDirectContext *  context, sk_sp< SkImage >  image, GrBackendTexture *  backendTexture, BackendTextureReleaseProc *  backendTextureReleaseProc  )

inline

Definition at line 303 of file SkImageGanesh.h.

                                                                                             {
    return MakeBackendTextureFromImage(context, std::move(image), backendTexture,
                                       backendTextureReleaseProc);
}

GetContext() [1/2]

GrDirectContext * SkImages::GetContext ( const sk_sp< const SkImage > &  src )

inline

Definition at line 111 of file SkImageChromium.h.

                                                                    {
    return GetContext(src.get());
}

GetContext() [2/2]

GrDirectContext * SkImages::GetContext

(

const SkImage *

src

)

Returns the GPU context associated with this image or nullptr if the image is not Ganesh-backed. We expose this only to help transition certain API calls and do not intend for this to stick around forever.

Definition at line 448 of file SkImage_GaneshBase.cpp.

                                                {
    if (!src || !as_IB(src)->isGaneshBacked()) {
        return nullptr;
    }
    return as_IB(src)->directContext();
}

make_texture_image_from_lazy()

static sk_sp< SkImage > SkImages::make_texture_image_from_lazy ( skgpu::graphite::Recorder *  recorder, const SkImage_Lazy *  img, SkImage::RequiredProperties  requiredProps  )

static

Definition at line 350 of file ImageFactories.cpp.

                                                                                            {
    // 1. Ask the generator to natively create one.
    {
        if (img->type() == SkImage_Base::Type::kLazyPicture) {
            sk_sp<SkImage> newImage =
                    generate_picture_texture(recorder,
                                             static_cast<const SkImage_Picture*>(img),
                                             img->imageInfo(),
                                             requiredProps);
            if (newImage) {
                SkASSERT(as_IB(newImage)->isGraphiteBacked());
                return newImage;
            }
        }
        // There is not an analog to GrTextureGenerator for Graphite yet, but if there was,
        // we would want to call it here.
    }
 
    // 2. Ask the generator to return a bitmap, which the GPU can convert.
    {
        SkBitmap bitmap;
        if (img->getROPixels(nullptr, &bitmap, SkImage_Lazy::CachingHint::kDisallow_CachingHint)) {
            return skgpu::graphite::MakeFromBitmap(recorder,
                                                   img->imageInfo().colorInfo(),
                                                   bitmap,
                                                   nullptr,
                                                   skgpu::Budgeted::kNo,
                                                   requiredProps,
                                                   "LazySkImageBitmapTexture");
        }
    }
 
    return nullptr;
}

MakeBackendTextureFromImage()

bool SkImages::MakeBackendTextureFromImage	(	GrDirectContext *	context,
		sk_sp< SkImage >	image,
		GrBackendTexture *	backendTexture,
		BackendTextureReleaseProc *	backendTextureReleaseProc
	)

Extracts the backendTexture from an existing SkImage. If the image is not already GPU-backed, the raster data will be uploaded as a texture and returned. If this is the only reference to the image, the old image's texture will be moved out of the passed in image. If the image is shared (has a refcount > 1), the texture will be copied and then returned.

Parameters

context	GPU context
image	image, either CPU-backed or GPU-backed
backendTexture	Will be set to the underlying texture of the image.
backendTextureReleaseProc	Called when the texture is released

Returns

false if image cannot be uploaded.

Definition at line 67 of file SkImage_GaneshFactories.cpp.

                                                                         {
    if (!image || !backendTexture || !releaseProc) {
        return false;
    }
 
    auto [view, ct] = skgpu::ganesh::AsView(direct, image, skgpu::Mipmapped::kNo);
    if (!view) {
        return false;
    }
 
    // Flush any pending IO on the texture.
    direct->priv().flushSurface(view.proxy());
 
    GrTexture* texture = view.asTextureProxy()->peekTexture();
    if (!texture) {
        return false;
    }
    // We must make a copy of the image if the image is not unique, if the GrTexture owned by the
    // image is not unique, or if the texture wraps an external object.
    if (!image->unique() || !texture->unique() || texture->resourcePriv().refsWrappedObjects()) {
        // onMakeSubset will always copy the image.
        image = as_IB(image)->onMakeSubset(direct, image->bounds());
        if (!image) {
            return false;
        }
        return MakeBackendTextureFromImage(direct, std::move(image), backendTexture, releaseProc);
    }
 
    SkASSERT(!texture->resourcePriv().refsWrappedObjects());
    SkASSERT(texture->unique());
    SkASSERT(image->unique());
 
    // Take a reference to the GrTexture and release the image.
    sk_sp<GrTexture> textureRef = sk_ref_sp(texture);
    view.reset();
    image = nullptr;
    SkASSERT(textureRef->unique());
 
    // Steal the backend texture from the GrTexture, releasing the GrTexture in the process.
    return GrTexture::StealBackendTexture(std::move(textureRef), backendTexture, releaseProc);
}

MakeWithFilter() [1/3]

sk_sp< SkImage > SkImages::MakeWithFilter	(	GrRecordingContext *	context,
		sk_sp< SkImage >	src,
		const SkImageFilter *	filter,
		const SkIRect &	subset,
		const SkIRect &	clipBounds,
		SkIRect *	outSubset,
		SkIPoint *	offset
	)

Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing color, position, and size. subset is the bounds of src that are processed by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset is required storage for the actual bounds of the filtered SkImage. offset is required storage for translation of returned SkImage.

Returns nullptr if SkImage could not be created or if the recording context provided doesn't match the GPU context in which the image was created. If nullptr is returned, outSubset and offset are undefined.

Useful for animation of SkImageFilter that varies size from frame to frame. Returned SkImage is created larger than required by filter so that GPU texture can be reused with different sized effects. outSubset describes the valid bounds of GPU texture returned. offset translates the returned SkImage to keep subsequent animation frames aligned with respect to each other.

Parameters

context	the GrRecordingContext in play - if it exists
filter	how SkImage is sampled when transformed
subset	bounds of SkImage processed by filter
clipBounds	expected bounds of filtered SkImage
outSubset	storage for returned SkImage bounds
offset	storage for returned SkImage translation

Returns

filtered SkImage, or nullptr

Definition at line 421 of file SkImage_GaneshBase.cpp.

                                                {
    if (!rContext || !src || !filter) {
        return nullptr;
    }
 
    GrSurfaceOrigin origin = kTopLeft_GrSurfaceOrigin;
    if (as_IB(src)->isGaneshBacked()) {
        SkImage_GaneshBase* base = static_cast<SkImage_GaneshBase*>(src.get());
        origin = base->origin();
    }
 
    sk_sp<skif::Backend> backend =
            skif::MakeGaneshBackend(sk_ref_sp(rContext), origin, {}, src->colorType());
    return as_IFB(filter)->makeImageWithFilter(std::move(backend),
                                               std::move(src),
                                               subset,
                                               clipBounds,
                                               outSubset,
                                               offset);
}

MakeWithFilter() [2/3]

sk_sp< SkImage > SkImages::MakeWithFilter	(	sk_sp< SkImage >	src,
		const SkImageFilter *	filter,
		const SkIRect &	subset,
		const SkIRect &	clipBounds,
		SkIRect *	outSubset,
		SkIPoint *	offset
	)

Creates a filtered SkImage on the CPU. filter processes the src image, potentially changing the color, position, and size. subset is the bounds of src that are processed by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset is required storage for the actual bounds of the filtered SkImage. offset is required storage for translation of returned SkImage.

Returns nullptr a filtered result could not be created. If nullptr is returned, outSubset and offset are undefined.

Useful for animation of SkImageFilter that varies size from frame to frame. outSubset describes the valid bounds of returned image. offset translates the returned SkImage to keep subsequent animation frames aligned with respect to each other.

Parameters

src	the image to be filtered
filter	the image filter to be applied
subset	bounds of SkImage processed by filter
clipBounds	expected bounds of filtered SkImage
outSubset	storage for returned SkImage bounds
offset	storage for returned SkImage translation

Returns

filtered SkImage, or nullptr

Definition at line 100 of file SkImage_RasterFactories.cpp.

                                                {
    if (!src || !filter) {
        return nullptr;
    }
 
    sk_sp<skif::Backend> backend = skif::MakeRasterBackend({}, src->colorType());
    return as_IFB(filter)->makeImageWithFilter(std::move(backend),
                                               std::move(src),
                                               subset,
                                               clipBounds,
                                               outSubset,
                                               offset);
}

MakeWithFilter() [3/3]

sk_sp< SkImage > SkImages::MakeWithFilter	(	skgpu::graphite::Recorder *	recorder,
		sk_sp< SkImage >	src,
		const SkImageFilter *	filter,
		const SkIRect &	subset,
		const SkIRect &	clipBounds,
		SkIRect *	outSubset,
		SkIPoint *	offset
	)

Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing color, position, and size. subset is the bounds of src that are processed by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset is required storage for the actual bounds of the filtered SkImage. offset is required storage for translation of returned SkImage.

Returns nullptr if SkImage could not be created. If nullptr is returned, outSubset and offset are undefined.

Useful for animation of SkImageFilter that varies size from frame to frame. Returned SkImage is created larger than required by filter so that GPU texture can be reused with different sized effects. outSubset describes the valid bounds of GPU texture returned. offset translates the returned SkImage to keep subsequent animation frames aligned with respect to each other.

Parameters

recorder	the recorder in which the filtering operation is to be performed
filter	how SkImage is sampled when transformed
subset	bounds of SkImage processed by filter
clipBounds	expected bounds of filtered SkImage
outSubset	storage for returned SkImage bounds
offset	storage for returned SkImage translation

Returns

filtered SkImage, or nullptr

Definition at line 298 of file ImageFactories.cpp.

                                                {
    if (!recorder || !src || !filter) {
        return nullptr;
    }
 
    sk_sp<skif::Backend> backend = skif::MakeGraphiteBackend(recorder, {}, src->colorType());
    return as_IFB(filter)->makeImageWithFilter(std::move(backend),
                                               std::move(src),
                                               subset,
                                               clipBounds,
                                               outSubset,
                                               offset);
}

new_wrapped_texture_common()

static sk_sp< SkImage > SkImages::new_wrapped_texture_common ( GrRecordingContext *  rContext, const GrBackendTexture &  backendTex, GrColorType  colorType, GrSurfaceOrigin  origin, SkAlphaType  at, sk_sp< SkColorSpace >  colorSpace, GrWrapOwnership  ownership, sk_sp< skgpu::RefCntedCallback >  releaseHelper  )

static

Definition at line 167 of file SkImage_GaneshFactories.cpp.

                                                                                             {
    if (!backendTex.isValid() || backendTex.width() <= 0 || backendTex.height() <= 0) {
        return nullptr;
    }
 
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
    sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
            backendTex, ownership, GrWrapCacheable::kNo, kRead_GrIOType, std::move(releaseHelper));
    if (!proxy) {
        return nullptr;
    }
 
    skgpu::Swizzle swizzle =
            rContext->priv().caps()->getReadSwizzle(proxy->backendFormat(), colorType);
    GrSurfaceProxyView view(std::move(proxy), origin, swizzle);
    SkColorInfo info(GrColorTypeToSkColorType(colorType), at, std::move(colorSpace));
    return sk_make_sp<SkImage_Ganesh>(
            sk_ref_sp(rContext), kNeedNewImageUniqueID, std::move(view), std::move(info));
}

PinnableRasterFromBitmap()

sk_sp< SkImage > SkImages::PinnableRasterFromBitmap

(

const SkBitmap &

bm

)

Like SkImagePriv::SkMakeImageFromRasterBitmap, except this can be pinned using skgpu::ganesh::PinAsTexture and CopyPixelMode is never.

Definition at line 54 of file SkImage_RasterPinnable.cpp.

                                                            {
    if (!SkImageInfoIsValid(bm.info()) || bm.rowBytes() < bm.info().minRowBytes()) {
        return nullptr;
    }
 
    return sk_make_sp<SkImage_RasterPinnable>(bm);
}

PromiseTextureFrom() [1/3]

sk_sp< SkImage > SkImages::PromiseTextureFrom	(	sk_sp< GrContextThreadSafeProxy >	gpuContextProxy,
		const GrBackendFormat &	backendFormat,
		SkISize	dimensions,
		skgpu::Mipmapped	mipmapped,
		GrSurfaceOrigin	origin,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		PromiseImageTextureFulfillProc	textureFulfillProc,
		PromiseImageTextureReleaseProc	textureReleaseProc,
		PromiseImageTextureContext	textureContext
	)

Create a new GPU-backed SkImage that is very similar to an SkImage created by BorrowTextureFrom. 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 skgpu::Mipmapped state. The resulting SkImage can be drawn to a GrDeferredDisplayListRecorder 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)

Parameters

gpuContextProxy	the thread-safe proxy of the gpu context. required.
backendFormat	format of promised gpu texture
dimensions	width & height of promised gpu texture
mipmapped	mip mapped state of promised gpu texture
origin	surface origin of promised gpu texture
colorType	color type of promised gpu texture
alphaType	alpha type of promised gpu texture
colorSpace	range of colors; may be nullptr
textureFulfillProc	function called to get actual gpu texture
textureReleaseProc	function called when texture can be deleted
textureContext	state passed to textureFulfillProc and textureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 316 of file SkImage_GaneshFactories.cpp.

                                                                             {
    // Our contract is that we will always call the release proc even on failure.
    // We use the helper to convey the context, so we need to ensure make doesn't fail.
    textureReleaseProc = textureReleaseProc ? textureReleaseProc : [](void*) {};
    auto releaseHelper = skgpu::RefCntedCallback::Make(textureReleaseProc, textureContext);
    SkImageInfo info = SkImageInfo::Make(dimensions, colorType, alphaType, colorSpace);
    if (!SkImageInfoIsValid(info)) {
        return nullptr;
    }
 
    if (!threadSafeProxy) {
        return nullptr;
    }
 
    if (dimensions.isEmpty()) {
        return nullptr;
    }
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
    if (GrColorType::kUnknown == grColorType) {
        return nullptr;
    }
 
    if (!threadSafeProxy->priv().caps()->areColorTypeAndFormatCompatible(grColorType,
                                                                         backendFormat)) {
        return nullptr;
    }
 
    auto proxy = SkImage_GaneshBase::MakePromiseImageLazyProxy(threadSafeProxy.get(),
                                                               dimensions,
                                                               backendFormat,
                                                               mipmapped,
                                                               textureFulfillProc,
                                                               std::move(releaseHelper));
    if (!proxy) {
        return nullptr;
    }
    skgpu::Swizzle swizzle =
            threadSafeProxy->priv().caps()->getReadSwizzle(backendFormat, grColorType);
    GrSurfaceProxyView view(std::move(proxy), origin, swizzle);
    sk_sp<GrImageContext> ctx(GrImageContextPriv::MakeForPromiseImage(std::move(threadSafeProxy)));
    return sk_make_sp<SkImage_Ganesh>(std::move(ctx),
                                      kNeedNewImageUniqueID,
                                      std::move(view),
                                      SkColorInfo(colorType, alphaType, std::move(colorSpace)));
}

PromiseTextureFrom() [2/3]

sk_sp< SkImage > SkImages::PromiseTextureFrom	(	skgpu::graphite::Recorder *	recorder,
		SkISize	dimensions,
		const skgpu::graphite::TextureInfo &	textureInfo,
		const SkColorInfo &	colorInfo,
		skgpu::graphite::Volatile	isVolatile,
		GraphitePromiseTextureFulfillProc	fulfillProc,
		GraphitePromiseImageReleaseProc	imageReleaseProc,
		GraphitePromiseTextureReleaseProc	textureReleaseProc,
		GraphitePromiseImageContext	imageContext
	)

Definition at line 218 of file ImageFactories.cpp.

                                                                            {
    return PromiseTextureFrom(recorder,
                              dimensions,
                              textureInfo,
                              colorInfo,
                              skgpu::Origin::kTopLeft,
                              isVolatile,
                              fulfillProc,
                              imageReleaseProc,
                              textureReleaseProc,
                              imageContext);
}

PromiseTextureFrom() [3/3]

sk_sp< SkImage > SkImages::PromiseTextureFrom	(	skgpu::graphite::Recorder *	recorder,
		SkISize	dimensions,
		const skgpu::graphite::TextureInfo &	textureInfo,
		const SkColorInfo &	colorInfo,
		skgpu::Origin	origin,
		skgpu::graphite::Volatile	isVolatile,
		GraphitePromiseTextureFulfillProc	fulfillProc,
		GraphitePromiseImageReleaseProc	imageReleaseProc,
		GraphitePromiseTextureReleaseProc	textureReleaseProc,
		GraphitePromiseImageContext	imageContext,
		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 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.

Parameters

recorder	the recorder that will capture the commands creating the image
dimensions	width & height of promised gpu texture
textureInfo	structural information for the promised gpu texture
colorInfo	color type, alpha type and colorSpace information for the image
origin	Whether the Texture logically treats the origin as TopLeft or BottomLeft
isVolatile	volatility of the promise image
fulfill	function called to get the actual backend texture, and the instance for the GraphitePromiseTextureReleaseProc
imageRelease	function called when any image-centric data can be deleted
textureRelease	function called when the backend texture can be deleted
imageContext	state passed to fulfill and imageRelease

Returns

created SkImage, or nullptr

Definition at line 165 of file ImageFactories.cpp.

                                                        {
    // Our contract is that we will always call the _image_ release proc even on failure.
    // We use the helper to convey the imageContext, so we need to ensure Make doesn't fail.
    imageReleaseProc = imageReleaseProc ? imageReleaseProc : [](void*) {};
    auto releaseHelper = skgpu::RefCntedCallback::Make(imageReleaseProc, imageContext);
 
    if (!recorder) {
        SKGPU_LOG_W("Null Recorder");
        return nullptr;
    }
 
    const Caps* caps = recorder->priv().caps();
 
    SkImageInfo info = SkImageInfo::Make(dimensions, colorInfo);
    if (!SkImageInfoIsValid(info)) {
        SKGPU_LOG_W("Invalid SkImageInfo");
        return nullptr;
    }
 
    if (!caps->areColorTypeAndTextureInfoCompatible(colorInfo.colorType(), textureInfo)) {
        SKGPU_LOG_W("Incompatible SkColorType and TextureInfo");
        return nullptr;
    }
 
    // Non-YUVA promise images use the 'imageContext' for both the release proc and fulfill proc.
    sk_sp<TextureProxy> proxy = MakePromiseImageLazyProxy(caps,
                                                          dimensions,
                                                          textureInfo,
                                                          isVolatile,
                                                          std::move(releaseHelper),
                                                          fulfillProc,
                                                          imageContext,
                                                          textureReleaseProc,
                                                          std::move(label));
    if (!proxy) {
        return nullptr;
    }
 
    skgpu::Swizzle swizzle = caps->getReadSwizzle(colorInfo.colorType(), textureInfo);
    TextureProxyView view(std::move(proxy), swizzle, origin);
    return sk_make_sp<Image>(view, colorInfo);
}

PromiseTextureFromYUVA() [1/2]

sk_sp< SkImage > SkImages::PromiseTextureFromYUVA	(	sk_sp< GrContextThreadSafeProxy >	gpuContextProxy,
		const GrYUVABackendTextureInfo &	backendTextureInfo,
		sk_sp< SkColorSpace >	imageColorSpace,
		PromiseImageTextureFulfillProc	textureFulfillProc,
		PromiseImageTextureReleaseProc	textureReleaseProc,
		PromiseImageTextureContext	textureContexts[]
	)

This is similar to 'PromiseTextureFrom' but it creates a GPU-backed 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.

Parameters

gpuContextProxy	the thread-safe proxy of the gpu context. required.
backendTextureInfo	info about the promised yuva gpu texture
imageColorSpace	range of colors; may be nullptr
textureFulfillProc	function called to get actual gpu texture
textureReleaseProc	function called when texture can be deleted
textureContexts	state passed to textureFulfillProc and textureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 395 of file SkImage_GaneshYUVA.cpp.

                                                                                    {
    if (!backendTextureInfo.isValid()) {
        return nullptr;
    }
 
    SkISize planeDimensions[SkYUVAInfo::kMaxPlanes];
    int n = backendTextureInfo.yuvaInfo().planeDimensions(planeDimensions);
 
    // Our contract is that we will always call the release proc even on failure.
    // We use the helper to convey the context, so we need to ensure make doesn't fail.
    textureReleaseProc = textureReleaseProc ? textureReleaseProc : [](void*) {};
    sk_sp<skgpu::RefCntedCallback> releaseHelpers[4];
    for (int i = 0; i < n; ++i) {
        releaseHelpers[i] = skgpu::RefCntedCallback::Make(textureReleaseProc, textureContexts[i]);
    }
 
    if (!threadSafeProxy) {
        return nullptr;
    }
 
    SkAlphaType at =
            backendTextureInfo.yuvaInfo().hasAlpha() ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
    SkImageInfo info = SkImageInfo::Make(
            backendTextureInfo.yuvaInfo().dimensions(), kAssumedColorType, at, imageColorSpace);
    if (!SkImageInfoIsValid(info)) {
        return nullptr;
    }
 
    // Make a lazy proxy for each plane
    sk_sp<GrSurfaceProxy> proxies[4];
    for (int i = 0; i < n; ++i) {
        proxies[i] =
                SkImage_GaneshBase::MakePromiseImageLazyProxy(threadSafeProxy.get(),
                                                              planeDimensions[i],
                                                              backendTextureInfo.planeFormat(i),
                                                              skgpu::Mipmapped::kNo,
                                                              textureFulfillProc,
                                                              std::move(releaseHelpers[i]));
        if (!proxies[i]) {
            return nullptr;
        }
    }
    GrYUVATextureProxies yuvaTextureProxies(
            backendTextureInfo.yuvaInfo(), proxies, backendTextureInfo.textureOrigin());
    SkASSERT(yuvaTextureProxies.isValid());
    sk_sp<GrImageContext> ctx(GrImageContextPriv::MakeForPromiseImage(std::move(threadSafeProxy)));
    return sk_make_sp<SkImage_GaneshYUVA>(std::move(ctx),
                                          kNeedNewImageUniqueID,
                                          std::move(yuvaTextureProxies),
                                          std::move(imageColorSpace));
}

PromiseTextureFromYUVA() [2/2]

sk_sp< SkImage > SkImages::PromiseTextureFromYUVA	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::YUVABackendTextureInfo &	backendTextureInfo,
		sk_sp< SkColorSpace >	imageColorSpace,
		skgpu::graphite::Volatile	isVolatile,
		GraphitePromiseTextureFulfillProc	fulfillProc,
		GraphitePromiseImageReleaseProc	imageReleaseProc,
		GraphitePromiseTextureReleaseProc	textureReleaseProc,
		GraphitePromiseImageContext	imageContext,
		GraphitePromiseTextureFulfillContext	planeContexts[],
		std::string_view	label = {}
	)

This is similar to 'PromiseTextureFrom' but it creates a GPU-backed 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, and conversion to RGB. Separate 'fulfill' and 'textureRelease' calls are made for each texture. Each texture has its 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.

Parameters

recorder	the recorder that will capture the commands creating the image
backendTextureInfo	info about the promised yuva gpu texture(s)
imageColorSpace	range of colors; may be nullptr
isVolatile	volatility of the promise image
fulfill	function called to get the actual backend texture for a given GraphitePromiseTextureContext, and the instance for the GraphitePromiseTextureReleaseProc
imageRelease	function called when any image-centric data can be deleted
textureRelease	function called when the backend texture can be deleted
imageContext	state passed to imageRelease
planeContexts	states passed to fulfill for each plane

Returns

created SkImage, or nullptr

Definition at line 239 of file ImageFactories.cpp.

                                                            {
    // Our contract is that we will always call the _image_ release proc even on failure.
    // We use the helper to convey the imageContext, so we need to ensure Make doesn't fail.
    auto releaseHelper = skgpu::RefCntedCallback::Make(imageReleaseProc, imageContext);
    if (!recorder) {
        return nullptr;
    }
    // Precompute the dimensions for all promise texture planes
    SkISize planeDimensions[SkYUVAInfo::kMaxPlanes];
    if (!backendTextureInfo.yuvaInfo().planeDimensions(planeDimensions)) {
        return nullptr;
    }
 
    std::string labelStr(label);
    if (labelStr.empty()) {
        labelStr = "Wrapped_PromiseYUVPlane";
    } else {
        labelStr += "_PromiseYUVPlane";
    }
 
    TextureProxyView planes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < backendTextureInfo.numPlanes(); ++i) {
        sk_sp<TextureProxy> lazyProxy = MakePromiseImageLazyProxy(
                recorder->priv().caps(),
                planeDimensions[i],
                backendTextureInfo.planeTextureInfo(i),
                isVolatile,
                releaseHelper,
                fulfillProc,
                planeContexts[i],
                textureReleaseProc,
                labelStr);
        // Promise YUVA images assume the default rgba swizzle.
        planes[i] = TextureProxyView(std::move(lazyProxy));
    }
    return Image_YUVA::Make(recorder->priv().caps(), backendTextureInfo.yuvaInfo(),
                            SkSpan(planes), std::move(imageColorSpace));
}

RasterFromBitmap()

sk_sp< SkImage > SkImages::RasterFromBitmap

(

const SkBitmap &

bitmap

)

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 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.

Parameters

bitmap

SkImageInfo, row bytes, and pixels

Returns

created SkImage, or nullptr

Definition at line 74 of file SkImage_RasterFactories.cpp.

                                                    {
    if (!bm.pixelRef()) {
        return nullptr;
    }
 
    return SkMakeImageFromRasterBitmap(bm, kIfMutable_SkCopyPixelsMode);
}

RasterFromCompressedTextureData()

sk_sp< SkImage > SkImages::RasterFromCompressedTextureData	(	sk_sp< SkData >	data,
		int	width,
		int	height,
		SkTextureCompressionType	type
	)

Creates a CPU-backed SkImage from compressed data.

This method will decompress the compressed data and create an image wrapping it. Any mipmap levels present in the compressed data are discarded.

Parameters

data	compressed data to store in SkImage
width	width of full SkImage
height	height of full SkImage
type	type of compression used

Returns

created SkImage, or nullptr

Definition at line 122 of file SkImage_RasterFactories.cpp.

                                                                              {
    size_t expectedSize = SkCompressedFormatDataSize(type, {width, height}, false);
    if (!data || data->size() < expectedSize) {
        return nullptr;
    }
 
    SkAlphaType at =
            SkTextureCompressionTypeIsOpaque(type) ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
 
    SkImageInfo ii = SkImageInfo::MakeN32(width, height, at);
 
    if (!valid_args(ii, ii.minRowBytes(), nullptr)) {
        return nullptr;
    }
 
    SkBitmap bitmap;
    if (!bitmap.tryAllocPixels(ii)) {
        return nullptr;
    }
 
    if (!SkDecompress(std::move(data), {width, height}, type, &bitmap)) {
        return nullptr;
    }
 
    bitmap.setImmutable();
    return RasterFromBitmap(bitmap);
}

RasterFromData()

sk_sp< SkImage > SkImages::RasterFromData	(	const SkImageInfo &	info,
		sk_sp< SkData >	pixels,
		size_t	rowBytes
	)

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.

Parameters

info	contains width, height, SkAlphaType, SkColorType, SkColorSpace
pixels	address or pixel storage
rowBytes	size of pixel row or larger

Returns

SkImage sharing pixels, or nullptr

Definition at line 86 of file SkImage_RasterFactories.cpp.

                                                                                            {
    size_t size;
    if (!valid_args(info, rowBytes, &size) || !data) {
        return nullptr;
    }
 
    // did they give us enough data?
    if (data->size() < size) {
        return nullptr;
    }
 
    return sk_make_sp<SkImage_Raster>(info, std::move(data), rowBytes);
}

RasterFromPixmap()

sk_sp< SkImage > SkImages::RasterFromPixmap	(	const SkPixmap &	pixmap,
		RasterReleaseProc	rasterReleaseProc,
		ReleaseContext	releaseContext
	)

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.

Parameters

pixmap	SkImageInfo, pixel address, and row bytes
rasterReleaseProc	function called when pixels can be released; or nullptr
releaseContext	state passed to rasterReleaseProc; or nullptr

Returns

SkImage sharing pixmap

Definition at line 153 of file SkImage_RasterFactories.cpp.

                                                                                                  {
    size_t size;
    if (!valid_args(pmap.info(), pmap.rowBytes(), &size) || !pmap.addr()) {
        return nullptr;
    }
 
    sk_sp<SkData> data(SkData::MakeWithProc(pmap.addr(), size, proc, ctx));
    return sk_make_sp<SkImage_Raster>(pmap.info(), std::move(data), pmap.rowBytes());
}

RasterFromPixmapCopy()

sk_sp< SkImage > SkImages::RasterFromPixmapCopy

(

const SkPixmap &

pixmap

)

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.

Parameters

pixmap

SkImageInfo, pixel address, and row bytes

Returns

copy of SkPixmap pixels, or nullptr

example: https://fiddle.skia.org/c/@Image_RasterFromPixmapCopy

Definition at line 82 of file SkImage_RasterFactories.cpp.

                                                          {
    return MakeRasterCopyPriv(pmap, kNeedNewImageUniqueID);
}

SubsetTextureFrom() [1/2]

sk_sp< SkImage > SkImages::SubsetTextureFrom	(	GrDirectContext *	context,
		const SkImage *	img,
		const SkIRect &	subset
	)

Returns subset of this image as a texture-backed 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 source image could not be read or copied
• The source image is texture-backed and context does not match the source image's context.

Parameters

context	the non-null GrDirectContext to which the subset should be uploaded.
subset	bounds of returned SkImage

Returns

the subsetted image, uploaded as a texture, or nullptr

Definition at line 411 of file SkImage_GaneshBase.cpp.

                                                        {
    if (context == nullptr || img == nullptr) {
        return nullptr;
    }
    auto subsetImg = img->makeSubset(context, subset);
    return SkImages::TextureFromImage(context, subsetImg.get());
}

SubsetTextureFrom() [2/2]

sk_sp< SkImage > SkImages::SubsetTextureFrom	(	skgpu::graphite::Recorder *	recorder,
		const SkImage *	img,
		const SkIRect &	subset,
		SkImage::RequiredProperties	props = {}
	)

Returns subset of this image as a texture-backed 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 source image could not be read or copied
• The source image is texture-backed and context does not match the source image's context.

Parameters

recorder	the non-null recorder in which to create the new image.
img	Source image
subset	bounds of returned SkImage
props	properties the returned SkImage must possess (e.g. mipmaps)

Returns

the subsetted image, uploaded as a texture, or nullptr

Definition at line 287 of file ImageFactories.cpp.

                                                                  {
    if (!recorder || !img) {
        return nullptr;
    }
    auto subsetImg = img->makeSubset(recorder, subset, props);
    return SkImages::TextureFromImage(recorder, subsetImg, props);
}

TextureFromAHardwareBufferWithData()

SK_API sk_sp< SkImage > SkImages::TextureFromAHardwareBufferWithData	(	GrDirectContext *	context,
		const SkPixmap &	pixmap,
		AHardwareBuffer *	hardwareBuffer,
		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.

Parameters

context	GPU context
pixmap	SkPixmap that contains data to be uploaded to the AHardwareBuffer
hardwareBuffer	AHardwareBuffer Android hardware buffer
surfaceOrigin	surface origin for resulting image

Returns

created SkImage, or nullptr

TextureFromCompressedTexture()

sk_sp< SkImage > SkImages::TextureFromCompressedTexture	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	origin,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		TextureReleaseProc	textureReleaseProc = nullptr,
		ReleaseContext	releaseContext = nullptr
	)

Creates a GPU-backed 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 backend.

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.

Parameters

context	the GPU context
backendTexture	a texture already allocated by the GPU
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 kOpaq ue_SkAlphaType.
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()).
textureReleaseProc	function called when the backend texture can be released
releaseContext	state passed to textureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 127 of file SkImage_GaneshFactories.cpp.

                                                                           {
    auto releaseHelper = skgpu::RefCntedCallback::Make(textureReleaseProc, releaseContext);
 
    if (!context) {
        return nullptr;
    }
 
    const GrCaps* caps = context->priv().caps();
 
    if (!SkImage_GaneshBase::ValidateCompressedBackendTexture(caps, backendTexture, alphaType)) {
        return nullptr;
    }
 
    GrProxyProvider* proxyProvider = context->priv().proxyProvider();
    sk_sp<GrTextureProxy> proxy =
            proxyProvider->wrapCompressedBackendTexture(backendTexture,
                                                        kBorrow_GrWrapOwnership,
                                                        GrWrapCacheable::kNo,
                                                        std::move(releaseHelper));
    if (!proxy) {
        return nullptr;
    }
 
    SkTextureCompressionType type =
            GrBackendFormatToCompressionType(backendTexture.getBackendFormat());
    SkColorType ct = skgpu::CompressionTypeToSkColorType(type);
 
    GrSurfaceProxyView view(std::move(proxy), origin, skgpu::Swizzle::RGBA());
    return sk_make_sp<SkImage_Ganesh>(sk_ref_sp(context),
                                      kNeedNewImageUniqueID,
                                      std::move(view),
                                      SkColorInfo(ct, alphaType, std::move(colorSpace)));
}

TextureFromCompressedTextureData()

sk_sp< SkImage > SkImages::TextureFromCompressedTextureData	(	GrDirectContext *	direct,
		sk_sp< SkData >	data,
		int	width,
		int	height,
		SkTextureCompressionType	type,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		GrProtected	isProtected = GrProtected::kNo
	)

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.

Parameters

context	GPU context
data	compressed data to store in SkImage
width	width of full SkImage
height	height of full SkImage
type	type of compression used
mipmapped	does 'data' contain data for all the mipmap levels?
isProtected	do the contents of 'data' require DRM protection (on Vulkan)?

Returns

created SkImage, or nullptr

Definition at line 280 of file SkImage_GaneshFactories.cpp.

                                                                         {
    if (!direct || !data) {
        return nullptr;
    }
 
    GrBackendFormat beFormat = direct->compressedBackendFormat(type);
    if (!beFormat.isValid()) {
        sk_sp<SkImage> tmp = RasterFromCompressedTextureData(std::move(data), width, height, type);
        if (!tmp) {
            return nullptr;
        }
        return TextureFromImage(direct, tmp, mipmapped);
    }
 
    GrProxyProvider* proxyProvider = direct->priv().proxyProvider();
    sk_sp<GrTextureProxy> proxy = proxyProvider->createCompressedTextureProxy(
            {width, height}, skgpu::Budgeted::kYes, mipmapped, isProtected, type, std::move(data));
    if (!proxy) {
        return nullptr;
    }
    GrSurfaceProxyView view(std::move(proxy));
 
    SkColorType colorType = skgpu::CompressionTypeToSkColorType(type);
 
    return sk_make_sp<SkImage_Ganesh>(sk_ref_sp(direct),
                                      kNeedNewImageUniqueID,
                                      std::move(view),
                                      SkColorInfo(colorType, kOpaque_SkAlphaType, nullptr));
}

TextureFromImage() [1/4]

sk_sp< SkImage > SkImages::TextureFromImage	(	GrDirectContext *	dContext,
		const SkImage *	img,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		skgpu::Budgeted	budgeted = skgpu::Budgeted::kYes
	)

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 skgpu::Mipmapped::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. skgpu::Budgeted is ignored in this case. Returns nullptr if context is nullptr, or if SkImage was created with another GrDirectContext.

Parameters

GrDirectContext	the GrDirectContext in play, if it exists
SkImage	a non-null pointer to an SkImage.
skgpu::Mipmapped	Whether created SkImage texture must allocate mip map levels. Defaults to no.
skgpu::Budgeted	Whether to count a newly created texture for the returned image counts against the context's budget. Defaults to yes.

Returns

created SkImage, or nullptr

Definition at line 429 of file SkImage_GaneshFactories.cpp.

                                                        {
    if (!dContext || !img) {
        return nullptr;
    }
    auto ib = as_IB(img);
    if (!dContext->priv().caps()->mipmapSupport() || ib->dimensions().area() <= 1) {
        mipmapped = skgpu::Mipmapped::kNo;
    }
 
    if (ib->isGaneshBacked()) {
        if (!ib->context()->priv().matches(dContext)) {
            return nullptr;
        }
 
        if (mipmapped == skgpu::Mipmapped::kNo || ib->hasMipmaps()) {
            return sk_ref_sp(const_cast<SkImage_Base*>(ib));
        }
    }
    GrImageTexGenPolicy policy = budgeted == skgpu::Budgeted::kYes
                                         ? GrImageTexGenPolicy::kNew_Uncached_Budgeted
                                         : GrImageTexGenPolicy::kNew_Uncached_Unbudgeted;
    // TODO: Don't flatten YUVA images here. Add mips to the planes instead.
    auto [view, ct] = skgpu::ganesh::AsView(dContext, ib, mipmapped, policy);
    if (!view) {
        return nullptr;
    }
    SkASSERT(view.asTextureProxy());
    SkASSERT(mipmapped == skgpu::Mipmapped::kNo ||
             view.asTextureProxy()->mipmapped() == skgpu::Mipmapped::kYes);
    SkColorInfo colorInfo(GrColorTypeToSkColorType(ct), ib->alphaType(), ib->refColorSpace());
    return sk_make_sp<SkImage_Ganesh>(
            sk_ref_sp(dContext), ib->uniqueID(), std::move(view), std::move(colorInfo));
}

TextureFromImage() [2/4]

sk_sp< SkImage > SkImages::TextureFromImage ( GrDirectContext *  ctx, const sk_sp< const SkImage > &  img, skgpu::Mipmapped  m = skgpu::Mipmapped::kNo, skgpu::Budgeted  b = skgpu::Budgeted::kYes  )

inline

Definition at line 208 of file SkImageGanesh.h.

                                                                            {
    return TextureFromImage(ctx, img.get(), m, b);
}

TextureFromImage() [3/4]

sk_sp< SkImage > SkImages::TextureFromImage	(	skgpu::graphite::Recorder *	recorder,
		const SkImage *	image,
		SkImage::RequiredProperties	requiredProps = {}
	)

Returns an SkImage backed by a Graphite texture, using the provided Recorder for creation and uploads if necessary. The returned SkImage respects the required image properties' mipmap setting for non-Graphite SkImages; i.e., if mipmapping is required, the backing Graphite texture will have allocated mip map levels.

It is assumed that MIP maps are always supported by the GPU.

Returns original SkImage if the image is already Graphite-backed and the required mipmapping is compatible with the backing Graphite texture. If the required mipmapping is not compatible, nullptr will be returned.

Returns nullptr if no Recorder is provided, or if SkImage was created with another Recorder and work on that Recorder has not been submitted.

Parameters

Recorder	the Recorder to use for storing commands
RequiredProperties	properties the returned SkImage must possess (e.g. mipmaps)

Returns

created SkImage, or nullptr

Definition at line 387 of file ImageFactories.cpp.

                                                                         {
    if (!recorder || !image) {
        return nullptr;
    }
    if (image->dimensions().area() <= 1) {
        requiredProps.fMipmapped = false;
    }
 
    auto ib = as_IB(image);
    SkASSERT(!ib->isGaneshBacked());
 
    if (ib->isRasterBacked()) {
        auto raster = static_cast<const SkImage_Raster*>(ib);
        return skgpu::graphite::MakeFromBitmap(recorder,
                                               raster->imageInfo().colorInfo(),
                                               raster->bitmap(),
                                               raster->refMips(),
                                               skgpu::Budgeted::kNo,
                                               requiredProps,
                                               "RasterBitmapTexture");
    }
    if (ib->isLazyGenerated()) {
        return make_texture_image_from_lazy(
                recorder, static_cast<const SkImage_Lazy*>(ib), requiredProps);
    }
    SkASSERT(ib->isGraphiteBacked());
    return ib->makeSubset(recorder, ib->bounds(), requiredProps);
}

TextureFromImage() [4/4]

sk_sp< SkImage > SkImages::TextureFromImage ( skgpu::graphite::Recorder *  r, const sk_sp< const SkImage > &  img, SkImage::RequiredProperties  props = {}  )

inline

Definition at line 254 of file Image.h.

                                                                         {}) {
    return TextureFromImage(r, img.get(), props);
}

TextureFromYUVAImages()

sk_sp< SkImage > SkImages::TextureFromYUVAImages	(	skgpu::graphite::Recorder *	recorder,
		const SkYUVAInfo &	yuvaInfo,
		SkSpan< const sk_sp< SkImage > >	images,
		sk_sp< SkColorSpace >	imageColorSpace
	)

Creates an SkImage from YUV[A] planar SkImages associated with the recorder.

The images should have kGraphite type, and the result will be nullptr if any are not. The resulting SkImage will not take a ref on the given SkImages but will take a ref on the underlying TextureProxies. The releaseProcs, if any, for those Textures will be the ones set when the given SkImages were created.

Parameters

recorder	The recorder.
yuvaInfo	Structure describing the YUVA format
images	A set of SkImages containing YUVA data
imageColorSpace	Range of colors of the resulting image after conversion to RGB; may be nullptr

Returns

created SkImage, or nullptr

Definition at line 513 of file ImageFactories.cpp.

                                                                          {
    // This factory is just a view of the images, so does not actually trigger any work on the
    // recorder. It is just used to provide the Caps.
    return Image_YUVA::WrapImages(recorder->priv().caps(), yuvaInfo, images, imageColorSpace);
}

TextureFromYUVAPixmaps() [1/3]

sk_sp< SkImage > SkImages::TextureFromYUVAPixmaps	(	GrRecordingContext *	context,
		const SkYUVAPixmaps &	pixmaps,
		skgpu::Mipmapped	buildMips,
		bool	limitToMaxTextureSize,
		sk_sp< SkColorSpace >	imageColorSpace
	)

Creates a GPU-backed 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. SkYUVAPixmaps does not need to remain valid after this returns.

Parameters

context	GPU context
pixmaps	The planes as pixmaps with supported SkYUVAInfo that specifies conversion to RGB.
buildMips	create internal YUVA textures as mip map if kYes. This is silently ignored if the context does not support mip maps.
limitToMaxTextureSize	downscale image to GPU maximum texture size, if necessary
imageColorSpace	range of colors of the resulting image; may be nullptr

Returns

created SkImage, or nullptr

Definition at line 325 of file SkImage_GaneshYUVA.cpp.

                                                                           {
    if (!context) {
        return nullptr;
    }
 
    if (!pixmaps.isValid()) {
        return nullptr;
    }
 
    if (!context->priv().caps()->mipmapSupport()) {
        buildMips = skgpu::Mipmapped::kNo;
    }
 
    // Resize the pixmaps if necessary.
    int numPlanes = pixmaps.numPlanes();
    int maxTextureSize = context->priv().caps()->maxTextureSize();
    int maxDim = std::max(pixmaps.yuvaInfo().width(), pixmaps.yuvaInfo().height());
 
    SkYUVAPixmaps tempPixmaps;
    const SkYUVAPixmaps* pixmapsToUpload = &pixmaps;
    // We assume no plane is larger than the image size (and at least one plane is as big).
    if (maxDim > maxTextureSize) {
        if (!limitToMaxTextureSize) {
            return nullptr;
        }
        float scale = static_cast<float>(maxTextureSize) / maxDim;
        SkISize newDimensions = {
                std::min(static_cast<int>(pixmaps.yuvaInfo().width() * scale), maxTextureSize),
                std::min(static_cast<int>(pixmaps.yuvaInfo().height() * scale), maxTextureSize)};
        SkYUVAInfo newInfo = pixmaps.yuvaInfo().makeDimensions(newDimensions);
        SkYUVAPixmapInfo newPixmapInfo(newInfo, pixmaps.dataType(), /*row bytes*/ nullptr);
        tempPixmaps = SkYUVAPixmaps::Allocate(newPixmapInfo);
        SkSamplingOptions sampling(SkFilterMode::kLinear);
        if (!tempPixmaps.isValid()) {
            return nullptr;
        }
        for (int i = 0; i < numPlanes; ++i) {
            if (!pixmaps.plane(i).scalePixels(tempPixmaps.plane(i), sampling)) {
                return nullptr;
            }
        }
        pixmapsToUpload = &tempPixmaps;
    }
 
    // Convert to texture proxies.
    GrSurfaceProxyView views[SkYUVAInfo::kMaxPlanes];
    GrColorType pixmapColorTypes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < numPlanes; ++i) {
        // Turn the pixmap into a GrTextureProxy
        SkBitmap bmp;
        bmp.installPixels(pixmapsToUpload->plane(i));
        std::tie(views[i], std::ignore) = GrMakeUncachedBitmapProxyView(context, bmp, buildMips);
        if (!views[i]) {
            return nullptr;
        }
        pixmapColorTypes[i] = SkColorTypeToGrColorType(bmp.colorType());
    }
 
    GrYUVATextureProxies yuvaProxies(pixmapsToUpload->yuvaInfo(), views, pixmapColorTypes);
    SkASSERT(yuvaProxies.isValid());
    return sk_make_sp<SkImage_GaneshYUVA>(sk_ref_sp(context),
                                          kNeedNewImageUniqueID,
                                          std::move(yuvaProxies),
                                          std::move(imageColorSpace));
}

TextureFromYUVAPixmaps() [2/3]

sk_sp< SkImage > SkImages::TextureFromYUVAPixmaps	(	GrRecordingContext *	context,
		const SkYUVAPixmaps &	pixmaps,
		skgpu::Mipmapped	buildMips = skgpu::Mipmapped::kNo,
		bool	limitToMaxTextureSize = false
	)

Definition at line 318 of file SkImage_GaneshYUVA.cpp.

                                                                  {
    return TextureFromYUVAPixmaps(context, pixmaps, buildMips, limitToMaxTextureSize, nullptr);
}

TextureFromYUVAPixmaps() [3/3]

sk_sp< SkImage > SkImages::TextureFromYUVAPixmaps	(	skgpu::graphite::Recorder *	recorder,
		const SkYUVAPixmaps &	pixmaps,
		SkImage::RequiredProperties	requiredProps = {},
		bool	limitToMaxTextureSize = false,
		sk_sp< SkColorSpace >	imgColorSpace = nullptr,
		std::string_view	label = {}
	)

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.

Parameters

Recorder	The Recorder to use for storing commands
pixmaps	The planes as pixmaps with supported SkYUVAInfo that specifies conversion to RGB.
RequiredProperties	Properties the returned SkImage must possess (e.g. mipmaps)
limitToMaxTextureSize	Downscale image to GPU maximum texture size, if necessary
imgColorSpace	Range of colors of the resulting image; may be nullptr

Returns

Created SkImage, or nullptr

Definition at line 418 of file ImageFactories.cpp.

                                                            {
    if (!recorder) {
        return nullptr;
    }
 
    // Determine if we have to resize the pixmaps
    const int maxTextureSize = recorder->priv().caps()->maxTextureSize();
    const int maxDim = std::max(pixmaps.yuvaInfo().width(), pixmaps.yuvaInfo().height());
 
    SkYUVAPixmapInfo finalInfo = pixmaps.pixmapsInfo();
    if (maxDim > maxTextureSize) {
        if (!limitToMaxTextureSize) {
            return nullptr;
        }
        float scale = static_cast<float>(maxTextureSize) / maxDim;
        SkISize newDimensions = {
                std::min(static_cast<int>(pixmaps.yuvaInfo().width() * scale), maxTextureSize),
                std::min(static_cast<int>(pixmaps.yuvaInfo().height() * scale), maxTextureSize)};
        finalInfo = SkYUVAPixmapInfo(pixmaps.yuvaInfo().makeDimensions(newDimensions),
                                     pixmaps.dataType(),
                                     /*rowBytes=*/nullptr);
    }
 
    std::string labelStr(label);
    if (labelStr.empty()) {
        labelStr = "YUVRasterBitmapPlane";
    } else {
        labelStr += "_YUVBitmapPlane";
    }
 
    auto mipmapped = requiredProps.fMipmapped ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
    TextureProxyView planes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < finalInfo.yuvaInfo().numPlanes(); ++i) {
        SkBitmap bmp;
        if (maxDim > maxTextureSize) {
            // Rescale the data before uploading
            if (!bmp.tryAllocPixels(finalInfo.planeInfo(i)) ||
                !pixmaps.plane(i).scalePixels(bmp.pixmap(), SkFilterMode::kLinear)) {
                return nullptr;
            }
        } else {
            // Use original data to upload
            if (!bmp.installPixels(pixmaps.plane(i))) {
                return nullptr;
            }
        }
 
        auto [view, _] = MakeBitmapProxyView(recorder, bmp, /*mipmapsIn=*/nullptr,
                                             mipmapped,  skgpu::Budgeted::kNo,
                                             labelStr);
        planes[i] = std::move(view);
    }
    return Image_YUVA::Make(recorder->priv().caps(), finalInfo.yuvaInfo(),
                            SkSpan(planes), std::move(imageColorSpace));
}

TextureFromYUVATextures() [1/3]

sk_sp< SkImage > SkImages::TextureFromYUVATextures	(	GrRecordingContext *	context,
		const GrYUVABackendTextures &	yuvaTextures
	)

Definition at line 282 of file SkImage_GaneshYUVA.cpp.

                                                                                  {
    return TextureFromYUVATextures(context, yuvaTextures, nullptr, nullptr, nullptr);
}

TextureFromYUVATextures() [2/3]

sk_sp< SkImage > SkImages::TextureFromYUVATextures	(	GrRecordingContext *	context,
		const GrYUVABackendTextures &	yuvaTextures,
		sk_sp< SkColorSpace >	imageColorSpace,
		TextureReleaseProc	textureReleaseProc = nullptr,
		ReleaseContext	releaseContext = nullptr
	)

Creates a GPU-backed 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.

Parameters

context	GPU context
yuvaTextures	A set of textures containing YUVA data and a description of the data and transformation to RGBA.
imageColorSpace	range of colors of the resulting image after conversion to RGB; may be nullptr
textureReleaseProc	called when the backend textures can be released
releaseContext	state passed to textureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 287 of file SkImage_GaneshYUVA.cpp.

                                                                      {
    auto releaseHelper = skgpu::RefCntedCallback::Make(textureReleaseProc, releaseContext);
 
    GrProxyProvider* proxyProvider = context->priv().proxyProvider();
    int numPlanes = yuvaTextures.yuvaInfo().numPlanes();
    sk_sp<GrSurfaceProxy> proxies[SkYUVAInfo::kMaxPlanes];
    for (int plane = 0; plane < numPlanes; ++plane) {
        proxies[plane] = proxyProvider->wrapBackendTexture(yuvaTextures.texture(plane),
                                                           kBorrow_GrWrapOwnership,
                                                           GrWrapCacheable::kNo,
                                                           kRead_GrIOType,
                                                           releaseHelper);
        if (!proxies[plane]) {
            return {};
        }
    }
    GrYUVATextureProxies yuvaProxies(
            yuvaTextures.yuvaInfo(), proxies, yuvaTextures.textureOrigin());
 
    if (!yuvaProxies.isValid()) {
        return nullptr;
    }
 
    return sk_make_sp<SkImage_GaneshYUVA>(
            sk_ref_sp(context), kNeedNewImageUniqueID, yuvaProxies, imageColorSpace);
}

TextureFromYUVATextures() [3/3]

sk_sp< SkImage > SkImages::TextureFromYUVATextures	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::YUVABackendTextures &	yuvaBackendTextures,
		sk_sp< SkColorSpace >	imageColorSpace,
		TextureReleaseProc	releaseP = nullptr,
		ReleaseContext	releaseC = nullptr,
		std::string_view	label = {}
	)

Creates an SkImage from YUV[A] planar textures associated with the recorder.

Parameters

recorder	The recorder.
yuvaBackendTextures	A set of textures containing YUVA data and a description of the data and transformation to RGBA.
imageColorSpace	range of colors of the resulting image after conversion to RGB; may be nullptr
TextureReleaseProc	called when the backend textures can be released
ReleaseContext	state passed to TextureReleaseProc

Returns

created SkImage, or nullptr

Definition at line 479 of file ImageFactories.cpp.

                                                             {
    auto releaseHelper = skgpu::RefCntedCallback::Make(releaseP, releaseC);
    if (!recorder) {
        return nullptr;
    }
 
    std::string labelStr(label);
    if (labelStr.empty()) {
        labelStr = "Wrapped_YUVPlane";
    } else {
        labelStr += "_YUVPlane";
    }
 
    TextureProxyView planes[SkYUVAInfo::kMaxPlanes];
    for (int i = 0; i < yuvaTextures.yuvaInfo().numPlanes(); ++i) {
        sk_sp<Texture> texture = recorder->priv().resourceProvider()->createWrappedTexture(
                yuvaTextures.planeTexture(i), labelStr);
        if (!texture) {
            SKGPU_LOG_W("Failed to wrap backend texture for YUVA plane %d", i);
            return nullptr;
        }
        texture->setReleaseCallback(releaseHelper);
        planes[i] = TextureProxyView(TextureProxy::Wrap(std::move(texture)));
    }
 
    return Image_YUVA::Make(recorder->priv().caps(), yuvaTextures.yuvaInfo(),
                            SkSpan(planes), std::move(imageColorSpace));
}

validate_backend_texture()

static bool SkImages::validate_backend_texture ( const skgpu::graphite::Caps *  caps, const skgpu::graphite::BackendTexture &  texture, const SkColorInfo &  info  )

static

Definition at line 48 of file ImageFactories.cpp.

                                                              {
    if (!texture.isValid() || texture.dimensions().width() <= 0 ||
        texture.dimensions().height() <= 0) {
        return false;
    }
 
    if (!SkColorInfoIsValid(info)) {
        return false;
    }
 
    if (!caps->isTexturable(texture.info())) {
        return false;
    }
 
    return caps->areColorTypeAndTextureInfoCompatible(info.colorType(), texture.info());
}

WrapTexture() [1/3]

sk_sp< SkImage > SkImages::WrapTexture	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::BackendTexture &	backendTex,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		skgpu::Origin	origin,
		GenerateMipmapsFromBase	generateMipmapsFromBase,
		TextureReleaseProc	releaseP = nullptr,
		ReleaseContext	releaseC = nullptr,
		std::string_view	label = {}
	)

Creates an SkImage from a GPU texture associated with the recorder. The client is still responsible for managing the backend texture's lifetime.

SkImage is returned if the format of backendTexture is recognized and supported. Recognized formats vary by GPU back-end.

Parameters

recorder	The recorder
backendTexture	texture residing on GPU
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()).
origin	Whether the Texture logically treats the origin as TopLeft or BottomLeft
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.

Returns

created SkImage, or nullptr

Definition at line 67 of file ImageFactories.cpp.

                                                 {
    auto releaseHelper = skgpu::RefCntedCallback::Make(releaseP, releaseC);
 
    if (!recorder) {
        return nullptr;
    }
 
    const Caps* caps = recorder->priv().caps();
 
    SkColorInfo info(ct, at, std::move(cs));
 
    if (!validate_backend_texture(caps, backendTex, info)) {
        return nullptr;
    }
 
    if (label.empty()) {
        label = "WrappedImage";
    }
 
    sk_sp<Texture> texture =
            recorder->priv().resourceProvider()->createWrappedTexture(backendTex, std::move(label));
    if (!texture) {
        SKGPU_LOG_W("Texture creation failed");
        return nullptr;
    }
    texture->setReleaseCallback(std::move(releaseHelper));
 
    sk_sp<TextureProxy> proxy = TextureProxy::Wrap(std::move(texture));
    SkASSERT(proxy);
 
    skgpu::Swizzle swizzle = caps->getReadSwizzle(ct, backendTex.info());
    TextureProxyView view(std::move(proxy), swizzle, origin);
 
    if (genMipmaps == GenerateMipmapsFromBase::kYes) {
        if (view.proxy()->mipmapped() == skgpu::Mipmapped::kNo) {
            SKGPU_LOG_W("Failed SkImage:::WrapTexture because asked to generate mipmaps for "
                        "nonmipmapped texture");
            return nullptr;
        }
        if (!GenerateMipmaps(recorder, view.refProxy(), info)) {
            SKGPU_LOG_W("Failed SkImage::WrapTexture. Could not generate mipmaps.");
            return nullptr;
        }
    }
 
    return sk_make_sp<skgpu::graphite::Image>(view, info);
}

WrapTexture() [2/3]

sk_sp< SkImage > SkImages::WrapTexture	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::BackendTexture &	backendTex,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		skgpu::Origin	origin,
		TextureReleaseProc	releaseP = nullptr,
		ReleaseContext	releaseC = nullptr,
		std::string_view	label = {}
	)

Definition at line 124 of file ImageFactories.cpp.

                                                 {
    return WrapTexture(recorder,
                       backendTex,
                       ct,
                       at,
                       std::move(cs),
                       origin,
                       SkImages::GenerateMipmapsFromBase::kNo,
                       releaseP,
                       releaseC,
                       std::move(label));
}

WrapTexture() [3/3]

sk_sp< SkImage > SkImages::WrapTexture	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::BackendTexture &	backendTex,
		SkColorType	colorType,
		SkAlphaType	alphaType,
		sk_sp< SkColorSpace >	colorSpace,
		TextureReleaseProc	releaseP = nullptr,
		ReleaseContext	releaseC = nullptr,
		std::string_view	label = {}
	)

Definition at line 145 of file ImageFactories.cpp.

                                                 {
    return WrapTexture(recorder,
                       backendTex,
                       ct,
                       at,
                       std::move(cs),
                       skgpu::Origin::kTopLeft,
                       SkImages::GenerateMipmapsFromBase::kNo,
                       releaseP,
                       releaseC,
                       std::move(label));
}