SkSurfaces Namespace Reference

Typedefs
using	ReleaseContext = void *
using	BufferReleaseProc = void(*)(ReleaseContext)
using	PixelsReleaseProc = void(void *pixels, void *context)
using	RenderTargetReleaseProc = void(*)(ReleaseContext)
using	TextureReleaseProc = void(*)(ReleaseContext)
using	BackendHandleAccess = SkSurface::BackendHandleAccess

Enumerations
enum class	BackendSurfaceAccess { kNoAccess , kPresent }

Functions
SK_API sk_sp< SkSurface >	WrapAndroidHardwareBuffer (skgpu::graphite::Recorder *recorder, AHardwareBuffer *hardwareBuffer, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, BufferReleaseProc=nullptr, ReleaseContext=nullptr, bool fromWindow=false)
SK_API sk_sp< SkSurface >	WrapAndroidHardwareBuffer (GrDirectContext *context, AHardwareBuffer *hardwareBuffer, GrSurfaceOrigin origin, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, bool fromWindow=false)
SK_API sk_sp< SkSurface >	Null (int width, int height)
SK_API sk_sp< SkSurface >	Raster (const SkImageInfo &imageInfo, size_t rowBytes, const SkSurfaceProps *surfaceProps)
sk_sp< SkSurface >	Raster (const SkImageInfo &imageInfo, const SkSurfaceProps *props=nullptr)
SK_API sk_sp< SkSurface >	WrapPixels (const SkImageInfo &imageInfo, void *pixels, size_t rowBytes, const SkSurfaceProps *surfaceProps=nullptr)
sk_sp< SkSurface >	WrapPixels (const SkPixmap &pm, const SkSurfaceProps *props=nullptr)
SK_API sk_sp< SkSurface >	WrapPixels (const SkImageInfo &imageInfo, void *pixels, size_t rowBytes, PixelsReleaseProc, void *context, const SkSurfaceProps *surfaceProps=nullptr)
SK_API sk_sp< SkSurface >	WrapCAMetalLayer (GrRecordingContext *context, GrMTLHandle layer, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, GrMTLHandle *drawable) SK_API_AVAILABLE_CA_METAL_LAYER
SK_API sk_sp< SkSurface >	WrapMTKView (GrRecordingContext *context, GrMTLHandle mtkView, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps) SK_API_AVAILABLE(macos(10.11)
SK_API sk_sp< SkSurface >	ios (9.0)
SK_API sk_sp< SkSurface >	tvos (9.0))
SK_API sk_sp< SkSurface >	RenderTarget (GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false, bool isProtected=false)
sk_sp< SkSurface >	RenderTarget (GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, const SkSurfaceProps *surfaceProps)
sk_sp< SkSurface >	RenderTarget (GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo)
SK_API sk_sp< SkSurface >	RenderTarget (GrRecordingContext *context, const GrSurfaceCharacterization &characterization, skgpu::Budgeted budgeted)
SK_API sk_sp< SkSurface >	WrapBackendTexture (GrRecordingContext *context, const GrBackendTexture &backendTexture, GrSurfaceOrigin origin, int sampleCnt, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API sk_sp< SkSurface >	WrapBackendRenderTarget (GrRecordingContext *context, const GrBackendRenderTarget &backendRenderTarget, GrSurfaceOrigin origin, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *surfaceProps, RenderTargetReleaseProc releaseProc=nullptr, ReleaseContext releaseContext=nullptr)
SK_API GrBackendTexture	GetBackendTexture (SkSurface *, BackendHandleAccess)
SK_API GrBackendRenderTarget	GetBackendRenderTarget (SkSurface *, BackendHandleAccess)
SK_API void	ResolveMSAA (SkSurface *surface)
void	ResolveMSAA (const sk_sp< SkSurface > &surface)
SK_API sk_sp< SkImage >	AsImage (sk_sp< const SkSurface >)
SK_API sk_sp< SkImage >	AsImageCopy (sk_sp< const SkSurface >, const SkIRect *subset=nullptr, skgpu::Mipmapped=skgpu::Mipmapped::kNo)
SK_API sk_sp< SkSurface >	RenderTarget (skgpu::graphite::Recorder *, const SkImageInfo &imageInfo, skgpu::Mipmapped=skgpu::Mipmapped::kNo, const SkSurfaceProps *surfaceProps=nullptr, std::string_view label={})
SK_API sk_sp< SkSurface >	WrapBackendTexture (skgpu::graphite::Recorder *, const skgpu::graphite::BackendTexture &, SkColorType colorType, sk_sp< SkColorSpace > colorSpace, const SkSurfaceProps *props, TextureReleaseProc=nullptr, ReleaseContext=nullptr, std::string_view label={})

Typedef Documentation

BackendHandleAccess

using SkSurfaces::BackendHandleAccess = typedef SkSurface::BackendHandleAccess

Definition at line 167 of file SkSurfaceGanesh.h.

BufferReleaseProc

using SkSurfaces::BufferReleaseProc = typedef void (*)(ReleaseContext)

Definition at line 25 of file SurfaceAndroid.h.

PixelsReleaseProc

using SkSurfaces::PixelsReleaseProc = typedef void(void* pixels, void* context)

Definition at line 116 of file SkSurface.h.

ReleaseContext

typedef void * SkSurfaces::ReleaseContext

Caller data passed to RenderTarget/TextureReleaseProc; may be nullptr.

Definition at line 24 of file SurfaceAndroid.h.

RenderTargetReleaseProc

using SkSurfaces::RenderTargetReleaseProc = typedef void (*)(ReleaseContext)

User function called when supplied render target may be deleted.

Definition at line 34 of file SkSurfaceGanesh.h.

TextureReleaseProc

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

User function called when supplied texture may be deleted.

Definition at line 37 of file SkSurfaceGanesh.h.

Enumeration Type Documentation

BackendSurfaceAccess

enum class SkSurfaces::BackendSurfaceAccess

strong

Enumerator
kNoAccess	back-end surface will not be used by client
kPresent	back-end surface will be used for presenting to screen

Definition at line 44 of file SkSurface.h.

                                {
    kNoAccess,  //!< back-end surface will not be used by client
    kPresent,   //!< back-end surface will be used for presenting to screen
};

Function Documentation

AsImage()

sk_sp< SkImage > SkSurfaces::AsImage

(

sk_sp< const SkSurface >

surface

)

The 'AsImage' and 'AsImageCopy' API/entry points are currently only available for Graphite.

In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating an image for a surface, the client must explicitly indicate if a copy should be made. In both of the below calls the resource backing the surface will never change.

The 'AsImage' entry point has some major ramifications for the mutability of the returned SkImage. Since the originating surface and the returned image share the same backing, care must be taken by the client to ensure that the contents of the image reflect the desired contents when it is consumed by the gpu. Note: if the backing GPU buffer isn't textureable this method will return null. Graphite will not attempt to make a copy. Note: For 'AsImage', the mipmapping of the image will match that of the source surface.

The 'AsImageCopy' entry point allows subsetting and the addition of mipmaps (since a copy is already being made).

In Graphite, the legacy API call (i.e., makeImageSnapshot) will just always make a copy.

Definition at line 186 of file Surface_Graphite.cpp.

                                                       {
    if (!surface) {
        return nullptr;
    }
    auto sb = asConstSB(surface.get());
    if (!sb->isGraphiteBacked()) {
        return nullptr;
    }
    auto gs = static_cast<const Surface*>(surface.get());
    return gs->asImage();
}

AsImageCopy()

sk_sp< SkImage > SkSurfaces::AsImageCopy	(	sk_sp< const SkSurface >	surface,
		const SkIRect *	subset = nullptr,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo
	)

Definition at line 198 of file Surface_Graphite.cpp.

                                                     {
    if (!surface) {
        return nullptr;
    }
    auto sb = asConstSB(surface.get());
    if (!sb->isGraphiteBacked()) {
        return nullptr;
    }
    auto gs = static_cast<const Surface*>(surface.get());
    return gs->makeImageCopy(subset, mipmapped);
}

GetBackendRenderTarget()

GrBackendRenderTarget SkSurfaces::GetBackendRenderTarget	(	SkSurface *	surface,
		BackendHandleAccess	access
	)

Retrieves the back-end render target. If SkSurface has no back-end render target, an invalid object is returned. Call GrBackendRenderTarget::isValid to determine if the result is valid.

The returned GrBackendRenderTarget should be discarded if the SkSurface is drawn to or deleted.

Returns

GPU render target reference; invalid on failure

Definition at line 751 of file SkSurface_Ganesh.cpp.

                                                                                             {
    if (surface == nullptr) {
        return GrBackendRenderTarget();
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return GrBackendRenderTarget();
    }
    return static_cast<SkSurface_Ganesh*>(surface)->getBackendRenderTarget(access);
}

GetBackendTexture()

GrBackendTexture SkSurfaces::GetBackendTexture	(	SkSurface *	surface,
		BackendHandleAccess	access
	)

Retrieves the back-end texture. If SkSurface has no back-end texture, an invalid object is returned. Call GrBackendTexture::isValid to determine if the result is valid.

The returned GrBackendTexture should be discarded if the SkSurface is drawn to or deleted.

Returns

GPU texture reference; invalid on failure

Definition at line 740 of file SkSurface_Ganesh.cpp.

                                                                                   {
    if (surface == nullptr) {
        return GrBackendTexture();
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return GrBackendTexture();
    }
    return static_cast<SkSurface_Ganesh*>(surface)->getBackendTexture(access);
}

ios()

SK_API sk_sp< SkSurface > SkSurfaces::ios

(

9.

0

)

Null()

sk_sp< SkSurface > SkSurfaces::Null	(	int	width,
		int	height
	)

Returns SkSurface without backing pixels. Drawing to SkCanvas returned from SkSurface has no effect. Calling makeImageSnapshot() on returned SkSurface returns nullptr.

Parameters

width	one or greater
height	one or greater

Returns

SkSurface if width and height are positive; otherwise, nullptr

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

Definition at line 52 of file SkSurface_Null.cpp.

                                             {
    if (width < 1 || height < 1) {
        return nullptr;
    }
    return sk_sp<SkSurface>(new SkNullSurface(width, height));
}

Raster() [1/2]

sk_sp< SkSurface > SkSurfaces::Raster ( const SkImageInfo &  imageInfo, const SkSurfaceProps *  props = nullptr  )

inline

Definition at line 80 of file SkSurface.h.

                                                                      {
    return Raster(imageInfo, 0, props);
}

Raster() [2/2]

sk_sp< SkSurface > SkSurfaces::Raster	(	const SkImageInfo &	imageInfo,
		size_t	rowBytes,
		const SkSurfaceProps *	surfaceProps
	)

Allocates raster SkSurface. SkCanvas returned by SkSurface draws directly into those allocated pixels, which are zeroed before use. Pixel memory size is imageInfo.height() times imageInfo.minRowBytes() or rowBytes, if provided and non-zero.

Pixel memory is deleted when SkSurface is deleted.

Validity constraints include:

• info dimensions are greater than zero;
• info contains SkColorType and SkAlphaType supported by raster surface.

Parameters

imageInfo	width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width and height must be greater than zero
rowBytes	interval from one SkSurface row to the next.
props	LCD striping orientation and setting for device independent fonts; may be nullptr

Returns

SkSurface if parameters are valid and memory was allocated, else nullptr.

Definition at line 186 of file SkSurface_Raster.cpp.

                                                                                               {
    if (!SkSurfaceValidateRasterInfo(info)) {
        return nullptr;
    }
 
    sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, rowBytes);
    if (!pr) {
        return nullptr;
    }
    if (rowBytes) {
        SkASSERT(pr->rowBytes() == rowBytes);
    }
    return sk_make_sp<SkSurface_Raster>(info, std::move(pr), props);
}

RenderTarget() [1/5]

sk_sp< SkSurface > SkSurfaces::RenderTarget	(	GrRecordingContext *	context,
		const GrSurfaceCharacterization &	characterization,
		skgpu::Budgeted	budgeted
	)

Returns SkSurface on GPU indicated by context that is compatible with the provided characterization. budgeted selects whether allocation for pixels is tracked by context.

Parameters

context	GPU context
characterization	description of the desired SkSurface

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 553 of file SkSurface_Ganesh.cpp.

                                                      {
    if (!rContext || !c.isValid()) {
        return nullptr;
    }
 
    if (c.usesGLFBO0()) {
        // If we are making the surface we will never use FBO0.
        return nullptr;
    }
 
    if (c.vulkanSecondaryCBCompatible()) {
        return nullptr;
    }
 
    auto device = rContext->priv().createDevice(budgeted,
                                                c.imageInfo(),
                                                SkBackingFit::kExact,
                                                c.sampleCount(),
                                                skgpu::Mipmapped(c.isMipMapped()),
                                                c.isProtected(),
                                                c.origin(),
                                                c.surfaceProps(),
                                                skgpu::ganesh::Device::InitContents::kClear);
    if (!device) {
        return nullptr;
    }
 
    sk_sp<SkSurface> result = sk_make_sp<SkSurface_Ganesh>(std::move(device));
#ifdef SK_DEBUG
    if (result) {
        SkASSERT(result->isCompatible(c));
    }
#endif
 
    return result;
}

RenderTarget() [2/5]

sk_sp< SkSurface > SkSurfaces::RenderTarget ( GrRecordingContext *  context, skgpu::Budgeted  budgeted, const SkImageInfo &  imageInfo  )

inline

Definition at line 80 of file SkSurfaceGanesh.h.

                                                                   {
    if (!imageInfo.width() || !imageInfo.height()) {
        return nullptr;
    }
    return RenderTarget(context, budgeted, imageInfo, 0, kBottomLeft_GrSurfaceOrigin, nullptr);
}

RenderTarget() [3/5]

sk_sp< SkSurface > SkSurfaces::RenderTarget ( GrRecordingContext *  context, skgpu::Budgeted  budgeted, const SkImageInfo &  imageInfo, int  sampleCount, const SkSurfaceProps *  surfaceProps  )

inline

Definition at line 72 of file SkSurfaceGanesh.h.

                                                                         {
    return RenderTarget(
            context, budgeted, imageInfo, sampleCount, kBottomLeft_GrSurfaceOrigin, surfaceProps);
}

RenderTarget() [4/5]

sk_sp< SkSurface > SkSurfaces::RenderTarget	(	GrRecordingContext *	context,
		skgpu::Budgeted	budgeted,
		const SkImageInfo &	imageInfo,
		int	sampleCount,
		GrSurfaceOrigin	surfaceOrigin,
		const SkSurfaceProps *	surfaceProps,
		bool	shouldCreateWithMips = false,
		bool	isProtected = false
	)

Returns SkSurface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and SkColorType in SkImageInfo. budgeted selects whether allocation for pixels is tracked by context. imageInfo describes the pixel format in SkColorType, and transparency in SkAlphaType, and color matching in SkColorSpace.

sampleCount requests the number of samples per pixel. Pass zero to disable multi-sample anti-aliasing. The request is rounded up to the next supported count, or rounded down if it is larger than the maximum supported count.

surfaceOrigin pins either the top-left or the bottom-left corner to the origin.

shouldCreateWithMips hints that SkImage returned by makeImageSnapshot() is mip map.

Parameters

context	GPU context
imageInfo	width, height, SkColorType, SkAlphaType, SkColorSpace; width, or height, or both, may be zero
sampleCount	samples per pixel, or 0 to disable full scene anti-aliasing
surfaceOrigin	How to align the pixel data.
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
shouldCreateWithMips	hint that SkSurface will host mip map images

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 592 of file SkSurface_Ganesh.cpp.

                                                {
    if (!rContext) {
        return nullptr;
    }
    sampleCount = std::max(1, sampleCount);
    skgpu::Mipmapped mipmapped =
            shouldCreateWithMips ? skgpu::Mipmapped::kYes : skgpu::Mipmapped::kNo;
 
    if (!rContext->priv().caps()->mipmapSupport()) {
        mipmapped = skgpu::Mipmapped::kNo;
    }
 
    auto device = rContext->priv().createDevice(budgeted,
                                                info,
                                                SkBackingFit::kExact,
                                                sampleCount,
                                                mipmapped,
                                                GrProtected(isProtected),
                                                origin,
                                                SkSurfacePropsCopyOrDefault(props),
                                                skgpu::ganesh::Device::InitContents::kClear);
    if (!device) {
        return nullptr;
    }
    return sk_make_sp<SkSurface_Ganesh>(std::move(device));
}

RenderTarget() [5/5]

sk_sp< SkSurface > SkSurfaces::RenderTarget	(	skgpu::graphite::Recorder *	recorder,
		const SkImageInfo &	imageInfo,
		skgpu::Mipmapped	mipmapped = skgpu::Mipmapped::kNo,
		const SkSurfaceProps *	surfaceProps = nullptr,
		std::string_view	label = {}
	)

In Graphite, while clients hold a ref on an SkSurface, the backing gpu object does not count against the budget. Once an SkSurface is freed, the backing gpu object may or may not become a scratch (i.e., reusable) resource but, if it does, it will be counted against the budget.

Definition at line 212 of file Surface_Graphite.cpp.

                                                    {
    if (label.empty()) {
        label = "SkSurfaceRenderTarget";
    }
    // The client is getting the ref on this surface so it must be unbudgeted.
    return skgpu::graphite::Surface::Make(recorder, info, std::move(label), skgpu::Budgeted::kNo,
                                          mipmapped, SkBackingFit::kExact, props);
}

ResolveMSAA() [1/2]

void SkSurfaces::ResolveMSAA ( const sk_sp< SkSurface > &  surface )

inline

Definition at line 202 of file SkSurfaceGanesh.h.

                                                         {
    return ResolveMSAA(surface.get());
}

ResolveMSAA() [2/2]

void SkSurfaces::ResolveMSAA

(

SkSurface *

surface

)

If a surface is a Ganesh-backed surface, is being drawn with MSAA, and there is a resolve texture, this call will insert a resolve command into the stream of gpu commands. In order for the resolve to actually have an effect, the work still needs to be flushed and submitted to the GPU after recording the resolve command. If a resolve is not supported or the SkSurface has no dirty work to resolve, then this call is a no-op.

This call is most useful when the SkSurface is created by wrapping a single sampled gpu texture, but asking Skia to render with MSAA. If the client wants to use the wrapped texture outside of Skia, the only way to trigger a resolve is either to call this command or use GrDirectContext::flush.

Definition at line 762 of file SkSurface_Ganesh.cpp.

                                     {
    if (!surface) {
        return;
    }
    auto sb = asSB(surface);
    if (!sb->isGaneshBacked()) {
        return;
    }
    auto gs = static_cast<SkSurface_Ganesh*>(surface);
    gs->resolveMSAA();
}

tvos()

SK_API sk_sp< SkSurface > SkSurfaces::tvos

(

9.

0

)

WrapAndroidHardwareBuffer() [1/2]

SK_API sk_sp< SkSurface > SkSurfaces::WrapAndroidHardwareBuffer	(	GrDirectContext *	context,
		AHardwareBuffer *	hardwareBuffer,
		GrSurfaceOrigin	origin,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps,
		bool	fromWindow = false
	)

Private; only to be used by Android Framework. Creates SkSurface from Android hardware buffer. Returned SkSurface takes a reference on the buffer. The ref on the buffer will be released when the SkSurface is destroyed and there is no pending work on the GPU involving the buffer.

Currently this is only supported for buffers that can be textured as well as rendered to. In other words that must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.

Parameters

context	GPU context
hardwareBuffer	AHardwareBuffer Android hardware buffer
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
fromWindow	Whether or not the AHardwareBuffer is part of an Android Window. Currently only used with Vulkan backend.

Returns

created SkSurface, or nullptr

WrapAndroidHardwareBuffer() [2/2]

SK_API sk_sp< SkSurface > SkSurfaces::WrapAndroidHardwareBuffer	(	skgpu::graphite::Recorder *	recorder,
		AHardwareBuffer *	hardwareBuffer,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps,
		BufferReleaseProc	= nullptr,
		ReleaseContext	= nullptr,
		bool	fromWindow = false
	)

Private; only to be used by Android Framework. Creates an SkSurface from an Android hardware buffer.

Upon success bufferReleaseProc is called when it is safe to delete the buffer in the backend API (accounting only for use of the buffer by this surface). If SkSurface creation fails bufferReleaseProc is called before this function returns.

Currently this is only supported for buffers that can be textured as well as rendered to. In other words the buffer must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.

Parameters

recorder	the applicable Graphite recorder
hardwareBuffer	an Android hardware buffer
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
bufferReleaseProc	function called when the buffer can be released
ReleaseContext	state passed to bufferReleaseProc
fromWindow	Whether or not the AHardwareBuffer is part of an Android Window. Currently only used with Vulkan backend.

Returns

created SkSurface, or nullptr

WrapBackendRenderTarget()

sk_sp< SkSurface > SkSurfaces::WrapBackendRenderTarget	(	GrRecordingContext *	context,
		const GrBackendRenderTarget &	backendRenderTarget,
		GrSurfaceOrigin	origin,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps,
		RenderTargetReleaseProc	releaseProc = nullptr,
		ReleaseContext	releaseContext = nullptr
	)

Wraps a GPU-backed buffer into SkSurface. Caller must ensure backendRenderTarget is valid for the lifetime of returned SkSurface.

SkSurface is returned if all parameters are valid. backendRenderTarget is valid if its pixel configuration agrees with colorSpace and context; for instance, if backendRenderTarget has an sRGB configuration, then context must support sRGB, and colorSpace must be present. Further, backendRenderTarget width and height must not exceed context capabilities, and the context must be able to support back-end render targets.

Upon success releaseProc is called when it is safe to delete the render target in the backend API (accounting only for use of the render target by this surface). If SkSurface creation fails releaseProc is called before this function returns.

Parameters

context	GPU context
backendRenderTarget	GPU intermediate memory buffer
colorSpace	range of colors
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
releaseProc	function called when backendRenderTarget can be released
releaseContext	state passed to releaseProc

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 698 of file SkSurface_Ganesh.cpp.

                                                                        {
    auto releaseHelper = skgpu::RefCntedCallback::Make(relProc, releaseContext);
 
    if (!rContext) {
        return nullptr;
    }
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
    if (grColorType == GrColorType::kUnknown) {
        return nullptr;
    }
 
    if (!validate_backend_render_target(rContext->priv().caps(), rt, grColorType)) {
        return nullptr;
    }
 
    auto proxyProvider = rContext->priv().proxyProvider();
    auto proxy = proxyProvider->wrapBackendRenderTarget(rt, std::move(releaseHelper));
    if (!proxy) {
        return nullptr;
    }
 
    auto device = rContext->priv().createDevice(grColorType,
                                                std::move(proxy),
                                                std::move(colorSpace),
                                                origin,
                                                SkSurfacePropsCopyOrDefault(props),
                                                skgpu::ganesh::Device::InitContents::kUninit);
    if (!device) {
        return nullptr;
    }
 
    return sk_make_sp<SkSurface_Ganesh>(std::move(device));
}

WrapBackendTexture() [1/2]

sk_sp< SkSurface > SkSurfaces::WrapBackendTexture	(	GrRecordingContext *	context,
		const GrBackendTexture &	backendTexture,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps,
		TextureReleaseProc	textureReleaseProc = nullptr,
		ReleaseContext	releaseContext = nullptr
	)

Wraps a GPU-backed texture into SkSurface. Caller must ensure the texture is valid for the lifetime of returned SkSurface. If sampleCnt greater than zero, creates an intermediate MSAA SkSurface which is used for drawing backendTexture.

SkSurface is returned if all parameters are valid. backendTexture is valid if its pixel configuration agrees with colorSpace and context; for instance, if backendTexture has an sRGB configuration, then context must support sRGB, and colorSpace must be present. Further, backendTexture width and height must not exceed context capabilities, and the context must be able to support back-end textures.

Upon success textureReleaseProc is called when it is safe to delete the texture in the backend API (accounting only for use of the texture by this surface). If SkSurface creation fails textureReleaseProc is called before this function returns.

Parameters

context	GPU context
backendTexture	texture residing on GPU
sampleCnt	samples per pixel, or 0 to disable full scene anti-aliasing
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
textureReleaseProc	function called when texture can be released
releaseContext	state passed to textureReleaseProc

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 626 of file SkSurface_Ganesh.cpp.

                                                                   {
    auto releaseHelper = skgpu::RefCntedCallback::Make(textureReleaseProc, releaseContext);
 
    if (!rContext) {
        RENDERENGINE_ABORTF("%s failed due to a null context ", __func__);
        return nullptr;
    }
    sampleCnt = std::max(1, sampleCnt);
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
    if (grColorType == GrColorType::kUnknown) {
        RENDERENGINE_ABORTF("%s failed due to an unsupported colorType %d", __func__, colorType);
        return nullptr;
    }
 
    if (!validate_backend_texture(rContext->priv().caps(), tex, sampleCnt, grColorType, true)) {
        return nullptr;
    }
 
    sk_sp<GrTextureProxy> proxy(rContext->priv().proxyProvider()->wrapRenderableBackendTexture(
            tex,
            sampleCnt,
            kBorrow_GrWrapOwnership,
            GrWrapCacheable::kNo,
            std::move(releaseHelper)));
    if (!proxy) {
        // TODO(scroggo,kjlubick) inline this into Android's AutoBackendTexture.cpp so we
        // don't have a sometimes-dependency on the GL backend.
#ifdef SK_IN_RENDERENGINE
        GrGLTextureInfo textureInfo;
        bool retrievedTextureInfo = GrBackendTextures::GetGLTextureInfo(tex, &textureInfo);
        RENDERENGINE_ABORTF(
                "%s failed to wrap the texture into a renderable target "
                "\n\tGrBackendTexture: (%i x %i) hasMipmaps: %i isProtected: %i texType: %i"
                "\n\t\tGrGLTextureInfo: success: %i fTarget: %u fFormat: %u"
                "\n\tmaxRenderTargetSize: %d",
                __func__,
                tex.width(),
                tex.height(),
                tex.hasMipmaps(),
                tex.isProtected(),
                static_cast<int>(tex.textureType()),
                retrievedTextureInfo,
                textureInfo.fTarget,
                textureInfo.fFormat,
                rContext->priv().caps()->maxRenderTargetSize());
#endif
        return nullptr;
    }
 
    auto device = rContext->priv().createDevice(grColorType,
                                                std::move(proxy),
                                                std::move(colorSpace),
                                                origin,
                                                SkSurfacePropsCopyOrDefault(props),
                                                skgpu::ganesh::Device::InitContents::kUninit);
    if (!device) {
        RENDERENGINE_ABORTF("%s failed to wrap the renderTarget into a surface", __func__);
        return nullptr;
    }
 
    return sk_make_sp<SkSurface_Ganesh>(std::move(device));
}

WrapBackendTexture() [2/2]

sk_sp< SkSurface > SkSurfaces::WrapBackendTexture	(	skgpu::graphite::Recorder *	recorder,
		const skgpu::graphite::BackendTexture &	backendTex,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	props,
		TextureReleaseProc	releaseP = nullptr,
		ReleaseContext	releaseC = nullptr,
		std::string_view	label = {}
	)

Wraps a GPU-backed texture in an SkSurface. Depending on the backend gpu API, the caller may be required to ensure the texture is valid for the lifetime of the returned SkSurface. The required lifetimes for the specific apis are: Metal: Skia will call retain on the underlying MTLTexture so the caller can drop it once this call returns.

SkSurface is returned if all the parameters are valid. The backendTexture is valid if its format agrees with colorSpace and recorder; for instance, if backendTexture has an sRGB configuration, then the recorder must support sRGB, and colorSpace must be present. Further, backendTexture's width and height must not exceed the recorder's capabilities, and the recorder must be able to support the back-end texture.

Definition at line 225 of file Surface_Graphite.cpp.

                                                          {
    auto releaseHelper = skgpu::RefCntedCallback::Make(releaseP, releaseC);
 
    if (!recorder) {
        return nullptr;
    }
 
    const Caps* caps = recorder->priv().caps();
 
    SkColorInfo info(ct, kPremul_SkAlphaType, std::move(cs));
 
    if (!validate_backend_texture(caps, backendTex, info)) {
        SKGPU_LOG_E("validate_backend_texture failed: backendTex.info = %s; colorType = %d",
                    backendTex.info().toString().c_str(),
                    info.colorType());
        return nullptr;
    }
 
    if (label.empty()) {
        label = "SkSurfaceWrappedTexture";
    }
 
    sk_sp<Texture> texture =
            recorder->priv().resourceProvider()->createWrappedTexture(backendTex, std::move(label));
    if (!texture) {
        return nullptr;
    }
    texture->setReleaseCallback(std::move(releaseHelper));
 
    sk_sp<TextureProxy> proxy = TextureProxy::Wrap(std::move(texture));
    SkISize deviceSize = proxy->dimensions();
    // Use kLoad for this device to preserve the existing contents of the wrapped backend texture.
    sk_sp<Device> device = Device::Make(recorder,
                                        std::move(proxy),
                                        deviceSize,
                                        info,
                                        SkSurfacePropsCopyOrDefault(props),
                                        LoadOp::kLoad);
    return device ? sk_make_sp<Surface>(std::move(device)) : nullptr;
}

WrapCAMetalLayer()

sk_sp< SkSurface > SkSurfaces::WrapCAMetalLayer	(	GrRecordingContext *	context,
		GrMTLHandle	layer,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps,
		GrMTLHandle *	drawable
	)

Creates SkSurface from CAMetalLayer. Returned SkSurface takes a reference on the CAMetalLayer. The ref on the layer will be released when the SkSurface is destroyed.

Only available when Metal API is enabled.

Will grab the current drawable from the layer and use its texture as a backendRT to create a renderable surface.

Parameters

context	GPU context
layer	GrMTLHandle (expected to be a CAMetalLayer*)
sampleCnt	samples per pixel, or 0 to disable full scene anti-aliasing
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
drawable	Pointer to drawable to be filled in when this surface is instantiated; may not be nullptr

Returns

created SkSurface, or nullptr

Definition at line 31 of file SkSurface_GaneshMtl.mm.

                                                         {
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
 
    CAMetalLayer* metalLayer = (__bridge CAMetalLayer*)layer;
    GrBackendFormat backendFormat = GrBackendFormats::MakeMtl(metalLayer.pixelFormat);
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
 
    SkISize dims = {(int)metalLayer.drawableSize.width, (int)metalLayer.drawableSize.height};
 
    GrProxyProvider::TextureInfo texInfo;
    texInfo.fMipmapped = skgpu::Mipmapped::kNo;
    texInfo.fTextureType = GrTextureType::k2D;
 
    sk_sp<GrRenderTargetProxy> proxy = proxyProvider->createLazyRenderTargetProxy(
            [layer, drawable](GrResourceProvider* resourceProvider,
                              const GrSurfaceProxy::LazySurfaceDesc& desc) {
                CAMetalLayer* metalLayer = (__bridge CAMetalLayer*)layer;
                id<CAMetalDrawable> currentDrawable = [metalLayer nextDrawable];
 
                GrMtlGpu* mtlGpu = (GrMtlGpu*)resourceProvider->priv().gpu();
                sk_sp<GrRenderTarget> surface;
                if (metalLayer.framebufferOnly) {
                    surface = GrMtlRenderTarget::MakeWrappedRenderTarget(
                            mtlGpu, desc.fDimensions, desc.fSampleCnt, currentDrawable.texture);
                } else {
                    surface = GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(
                            mtlGpu,
                            desc.fDimensions,
                            desc.fSampleCnt,
                            currentDrawable.texture,
                            GrWrapCacheable::kNo);
                }
                if (surface && desc.fSampleCnt > 1) {
                    surface->setRequiresManualMSAAResolve();
                }
 
                *drawable = (__bridge_retained GrMTLHandle)currentDrawable;
                return GrSurfaceProxy::LazyCallbackResult(std::move(surface));
            },
            backendFormat,
            dims,
            sampleCnt,
            sampleCnt > 1 ? GrInternalSurfaceFlags::kRequiresManualMSAAResolve
                          : GrInternalSurfaceFlags::kNone,
            metalLayer.framebufferOnly ? nullptr : &texInfo,
            GrMipmapStatus::kNotAllocated,
            SkBackingFit::kExact,
            skgpu::Budgeted::kYes,
            GrProtected::kNo,
            false,
            GrSurfaceProxy::UseAllocator::kYes);
 
    auto device = rContext->priv().createDevice(grColorType,
                                                std::move(proxy),
                                                std::move(colorSpace),
                                                origin,
                                                SkSurfacePropsCopyOrDefault(surfaceProps),
                                                skgpu::ganesh::Device::InitContents::kUninit);
    if (!device) {
        return nullptr;
    }
 
    return sk_make_sp<SkSurface_Ganesh>(std::move(device));
}

WrapMTKView()

sk_sp< SkSurface > SkSurfaces::WrapMTKView	(	GrRecordingContext *	context,
		GrMTLHandle	mtkView,
		GrSurfaceOrigin	origin,
		int	sampleCnt,
		SkColorType	colorType,
		sk_sp< SkColorSpace >	colorSpace,
		const SkSurfaceProps *	surfaceProps
	)

Creates SkSurface from MTKView. Returned SkSurface takes a reference on the MTKView. The ref on the layer will be released when the SkSurface is destroyed.

Only available when Metal API is enabled.

Will grab the current drawable from the layer and use its texture as a backendRT to create a renderable surface.

Parameters

context	GPU context
layer	GrMTLHandle (expected to be a MTKView*)
sampleCnt	samples per pixel, or 0 to disable full scene anti-aliasing
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Returns

created SkSurface, or nullptr

Definition at line 104 of file SkSurface_GaneshMtl.mm.

                                                                 {
    GrProxyProvider* proxyProvider = rContext->priv().proxyProvider();
 
    MTKView* mtkView = (__bridge MTKView*)view;
    GrBackendFormat backendFormat = GrBackendFormats::MakeMtl(mtkView.colorPixelFormat);
 
    GrColorType grColorType = SkColorTypeToGrColorType(colorType);
 
    SkISize dims = {(int)mtkView.drawableSize.width, (int)mtkView.drawableSize.height};
 
    GrProxyProvider::TextureInfo texInfo;
    texInfo.fMipmapped = skgpu::Mipmapped::kNo;
    texInfo.fTextureType = GrTextureType::k2D;
 
    sk_sp<GrRenderTargetProxy> proxy = proxyProvider->createLazyRenderTargetProxy(
            [view](GrResourceProvider* resourceProvider,
                   const GrSurfaceProxy::LazySurfaceDesc& desc) {
                MTKView* mtkView = (__bridge MTKView*)view;
                id<CAMetalDrawable> currentDrawable = [mtkView currentDrawable];
 
                GrMtlGpu* mtlGpu = (GrMtlGpu*)resourceProvider->priv().gpu();
                sk_sp<GrRenderTarget> surface;
                if (mtkView.framebufferOnly) {
                    surface = GrMtlRenderTarget::MakeWrappedRenderTarget(
                            mtlGpu, desc.fDimensions, desc.fSampleCnt, currentDrawable.texture);
                } else {
                    surface = GrMtlTextureRenderTarget::MakeWrappedTextureRenderTarget(
                            mtlGpu,
                            desc.fDimensions,
                            desc.fSampleCnt,
                            currentDrawable.texture,
                            GrWrapCacheable::kNo);
                }
                if (surface && desc.fSampleCnt > 1) {
                    surface->setRequiresManualMSAAResolve();
                }
 
                return GrSurfaceProxy::LazyCallbackResult(std::move(surface));
            },
            backendFormat,
            dims,
            sampleCnt,
            sampleCnt > 1 ? GrInternalSurfaceFlags::kRequiresManualMSAAResolve
                          : GrInternalSurfaceFlags::kNone,
            mtkView.framebufferOnly ? nullptr : &texInfo,
            GrMipmapStatus::kNotAllocated,
            SkBackingFit::kExact,
            skgpu::Budgeted::kYes,
            GrProtected::kNo,
            false,
            GrSurfaceProxy::UseAllocator::kYes);
 
    auto device = rContext->priv().createDevice(grColorType,
                                                std::move(proxy),
                                                std::move(colorSpace),
                                                origin,
                                                SkSurfacePropsCopyOrDefault(surfaceProps),
                                                skgpu::ganesh::Device::InitContents::kUninit);
    if (!device) {
        return nullptr;
    }
 
    return sk_make_sp<SkSurface_Ganesh>(std::move(device));
}

WrapPixels() [1/3]

sk_sp< SkSurface > SkSurfaces::WrapPixels	(	const SkImageInfo &	imageInfo,
		void *	pixels,
		size_t	rowBytes,
		const SkSurfaceProps *	surfaceProps = nullptr
	)

Allocates raster SkSurface. SkCanvas returned by SkSurface draws directly into the provided pixels.

SkSurface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains SkColorType and SkAlphaType supported by raster surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of SkColorType.

Pixel buffer size should be info height times computed rowBytes. Pixels are not initialized. To access pixels after drawing, peekPixels() or readPixels().

Parameters

imageInfo	width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width and height must be greater than zero
pixels	pointer to destination pixels buffer
rowBytes	interval from one SkSurface row to the next
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 179 of file SkSurface_Raster.cpp.

                                                         {
    return WrapPixels(info, pixels, rowBytes, nullptr, nullptr, props);
}

WrapPixels() [2/3]

sk_sp< SkSurface > SkSurfaces::WrapPixels	(	const SkImageInfo &	imageInfo,
		void *	pixels,
		size_t	rowBytes,
		PixelsReleaseProc	releaseProc,
		void *	context,
		const SkSurfaceProps *	surfaceProps = nullptr
	)

Allocates raster SkSurface. SkCanvas returned by SkSurface draws directly into the provided pixels. releaseProc is called with pixels and context when SkSurface is deleted.

SkSurface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains SkColorType and SkAlphaType supported by raster surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of SkColorType.

Pixel buffer size should be info height times computed rowBytes. Pixels are not initialized. To access pixels after drawing, call flush() or peekPixels().

Parameters

imageInfo	width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width and height must be greater than zero
pixels	pointer to destination pixels buffer
rowBytes	interval from one SkSurface row to the next
releaseProc	called when SkSurface is deleted; may be nullptr
context	passed to releaseProc; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Returns

SkSurface if all parameters are valid; otherwise, nullptr

Definition at line 160 of file SkSurface_Raster.cpp.

                                                         {
    if (nullptr == releaseProc) {
        context = nullptr;
    }
    if (!SkSurfaceValidateRasterInfo(info, rowBytes)) {
        return nullptr;
    }
    if (nullptr == pixels) {
        return nullptr;
    }
 
    return sk_make_sp<SkSurface_Raster>(info, pixels, rowBytes, releaseProc, context, props);
}

WrapPixels() [3/3]

sk_sp< SkSurface > SkSurfaces::WrapPixels ( const SkPixmap &  pm, const SkSurfaceProps *  props = nullptr  )

inline

Definition at line 112 of file SkSurface.h.

                                                                                              {
    return WrapPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), props);
}