skia2/site/user/api/SkSurface_Reference.md

SkSurface Reference

Surface

Class SkSurface

SkSurface is responsible for managing the pixels that a canvas draws into. The pixels can be allocated either in CPU memory (a raster surface) or on the GPU (a GrRenderTarget surface). SkSurface takes care of allocating a SkCanvas that will draw into the surface. Call surface->getCanvas to use that canvas (but don't delete it, it is owned by the surface). SkSurface always has non-zero dimensions. If there is a request for a new surface, and either of the requested dimensions are zero, then nullptr will be returned.

Overview

Topic	Description
Constants	enum and enum class, and their const values
Constructors	functions that construct SkSurface
Functions	global and class member functions
Related Functions	similar member functions grouped together

Constant

SkSurface related constants are defined by enum, enum class, #define, const, and constexpr.

Topic	Description
BackendHandleAccess	options to read and write back-end object
ContentChangeMode	parameter options for notifyContentWillChange
kDiscardWrite BackendHandleAccess	back-end object must be overwritten
kDiscard ContentChangeMode	discards surface on change
kFlushRead BackendHandleAccess	back-end object is readable
kFlushWrite BackendHandleAccess	back-end object is writable
kRetain ContentChangeMode	preserves surface on change

Related Function

SkSurface global, struct, and class related member functions share a topic.

Topic	Description
Miscellaneous	other functions
Pixels	functions with pixel access
Property	member values
Utility	rarely called management functions

Member Function

SkSurface member functions read and modify the structure properties.

Topic	Description
MakeFromBackendRenderTarget	creates Surface from GPU render target
MakeFromBackendTexture	creates Surface from GPU texture
MakeFromBackendTextureAsRenderTarget	creates Surface from GPU back-end render target
MakeNull	creates Surface without backing pixels
MakeRaster	creates Surface from SkImageInfo
MakeRasterDirect	creates Surface from SkImageInfo and Pixel Storage
MakeRasterDirectReleaseProc	creates Surface from SkImageInfo and Pixel Storage
MakeRasterN32Premul	creates Surface from width, height matching output
MakeRenderTarget	creates Surface pointing to new GPU memory buffer
characterize	sets Surface Characterization for threaded GPU processing
draw	draws Surface contents to canvas
flush	resolves pending I/O
flushAndSignalSemaphores	resolves pending I/O, and signal
generationID	returns unique ID
getBackendRenderTarget	returns the GPU reference to render target
getBackendTexture	returns the GPU reference to texture
getCanvas	returns Canvas that draws into Surface
height	returns pixel row count
makeImageSnapshot	creates Image capturing Surface contents
makeSurface	creates a compatible Surface
notifyContentWillChange	notifies that contents will be changed outside of Skia
peekPixels	copies Surface parameters to Pixmap
props	returns Surface Properties
readPixels	copies Rect of pixels
wait	pauses commands until signaled
width	returns pixel column count
writePixels	copies Rect of pixels

Constructor

SkSurface can be constructed or initialized by these functions, including C++ class constructors.

Topic	Description
MakeFromBackendRenderTarget	creates Surface from GPU render target
MakeFromBackendTexture	creates Surface from GPU texture
MakeFromBackendTextureAsRenderTarget	creates Surface from GPU back-end render target
MakeNull	creates Surface without backing pixels
MakeRaster	creates Surface from SkImageInfo
MakeRasterDirect	creates Surface from SkImageInfo and Pixel Storage
MakeRasterDirectReleaseProc	creates Surface from SkImageInfo and Pixel Storage
MakeRasterN32Premul	creates Surface from width, height matching output
MakeRenderTarget	creates Surface pointing to new GPU memory buffer
makeImageSnapshot	creates Image capturing Surface contents
makeSurface	creates a compatible Surface

MakeRasterDirect

static sk sp<SkSurface> MakeRasterDirect(const SkImageInfo& imageInfo, void* pixels, size_t rowBytes,
                                         const SkSurfaceProps* surfaceProps = nullptr)

Allocates raster Surface. Canvas returned by Surface draws directly into pixels.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains Color Type and Alpha Type supported by Raster Surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of Color Type.

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, Color Type, Alpha Type, Color Space, of Raster Surface; width and height must be greater than zero
pixels	pointer to destination pixels buffer
rowBytes	interval from one Surface row to the next
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

Example Output

---
-x-
---

See Also

MakeRasterDirectReleaseProc MakeRaster^[2] MakeRasterN32Premul SkCanvas::MakeRasterDirect

---

MakeRasterDirectReleaseProc

static sk sp<SkSurface> MakeRasterDirectReleaseProc(const SkImageInfo& imageInfo, void* pixels,
                                           size_t rowBytes, void (*releaseProc) (void* pixels,
                                           void* context) , void* context,
                                           const SkSurfaceProps* surfaceProps = nullptr)

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. releaseProc is called with pixels and context when Surface is deleted.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains Color Type and Alpha Type supported by Raster Surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of Color Type.

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, Color Type, Alpha Type, Color Space, of Raster Surface; width and height must be greater than zero
pixels	pointer to destination pixels buffer
rowBytes	interval from one Surface row to the next
releaseProc	called when Surface 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

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

Example Output

---
-x-
---
expected release context

See Also

MakeRasterDirect MakeRasterN32Premul MakeRaster^[2]

---

MakeRaster

static sk sp<SkSurface> MakeRaster(const SkImageInfo& imageInfo, size_t rowBytes,
                                   const SkSurfaceProps* surfaceProps)

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is imageInfo.height times rowBytes, or times imageInfo.minRowBytes() if rowBytes is zero. Pixel memory is deleted when Surface is deleted.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains Color Type and Alpha Type supported by Raster Surface; rowBytes is large enough to contain info width pixels of Color Type, or is zero.

If rowBytes is not zero, subsequent images returned by makeImageSnapshot have the same rowBytes.

Parameters

imageInfo	width, height, Color Type, Alpha Type, Color Space, of Raster Surface; width and height must be greater than zero
rowBytes	interval from one Surface row to the next; may be zero
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

Example Output

---
-x-
---

See Also

MakeRasterDirect MakeRasterN32Premul MakeRasterDirectReleaseProc

---

static sk sp<SkSurface> MakeRaster(const SkImageInfo& imageInfo,
                                   const SkSurfaceProps* props = nullptr)

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is imageInfo.height times imageInfo.minRowBytes(). Pixel memory is deleted when Surface is deleted.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains Color Type and Alpha Type supported by Raster Surface.

Parameters

imageInfo	width, height, Color Type, Alpha Type, Color Space, of Raster Surface; width and height must be greater than zero
props	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

See Also

MakeRasterDirect MakeRasterN32Premul MakeRasterDirectReleaseProc

---

MakeRasterN32Premul

static sk sp<SkSurface> MakeRasterN32Premul(int width, int height,
                                            const SkSurfaceProps* surfaceProps = nullptr)

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is height times width times four. Pixel memory is deleted when Surface is deleted.

Internally, sets Image Info to width, height, Native_Color_Type, and kPremul_SkAlphaType.

Surface is returned if width and height are greater than zero.

Use to create Surface that matches SkPMColor, the native pixel arrangement on the platform. Surface drawn to output device skips converting its pixel format.

Parameters

width	pixel column count; must be greater than zero
height	pixel row count; must be greater than zero
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

Example Output

---
-x-
---

See Also

MakeRasterDirect MakeRasterN32Premul MakeRasterDirectReleaseProc

---

MakeFromBackendTexture

static sk sp<SkSurface> MakeFromBackendTexture(GrContext* context,
                                               const GrBackendTexture& backendTexture,
                                               GrSurfaceOrigin origin, int sampleCnt,
                                               SkColorType colorType,
                                               sk sp<SkColorSpace> colorSpace,
                                               const SkSurfaceProps* surfaceProps)

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

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

If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.

Parameters

context	GPU Context
backendTexture	texture residing on GPU
origin	one of: kBottomLeft GrSurfaceOrigin, kTopLeft GrSurfaceOrigin
sampleCnt	samples per pixel, or 0 to disable full scene anti-aliasing
colorType	one of: kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType, kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

See Also

GrBackendTexture MakeFromBackendRenderTarget MakeRenderTarget^[2][3][4]

---

MakeFromBackendRenderTarget

static sk sp<SkSurface> MakeFromBackendRenderTarget(GrContext* context,
                                                   const GrBackendRenderTarget& backendRenderTarget,
                                                   GrSurfaceOrigin origin, SkColorType colorType,
                                                   sk sp<SkColorSpace> colorSpace,
                                                   const SkSurfaceProps* surfaceProps)

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

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

If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.

Parameters

context	GPU Context
backendRenderTarget	GPU intermediate memory buffer
origin	one of: kBottomLeft GrSurfaceOrigin, kTopLeft GrSurfaceOrigin
colorType	one of: kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType, kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType
colorSpace	range of colors
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

    SkPaint paint;
    paint.setTextSize(32);
    GrContext* context = canvas->getGrContext();
    if (!context) {
         canvas->drawString("GPU only!", 20, 40, paint);
         return;
    }
    sk_sp gpuSurface = SkSurface::MakeFromBackendRenderTarget(context,
            backEndRenderTarget, kTopLeft_GrSurfaceOrigin, kRGBA_8888_SkColorType,
            nullptr, nullptr);
    auto surfaceCanvas = gpuSurface->getCanvas();
    surfaceCanvas->drawString("GPU rocks!", 20, 40, paint);
    sk_sp image(gpuSurface->makeImageSnapshot());
    canvas->drawImage(image, 0, 0);

See Also

MakeFromBackendTexture MakeRenderTarget^[2][3][4]

---

MakeFromBackendTextureAsRenderTarget

static sk sp<SkSurface> MakeFromBackendTextureAsRenderTarget(GrContext* context,
                                            const GrBackendTexture& backendTexture,
                                            GrSurfaceOrigin origin, int sampleCnt,
                                            SkColorType colorType, sk sp<SkColorSpace> colorSpace,
                                            const SkSurfaceProps* surfaceProps)

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

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

Returned Surface is available only for drawing into, and cannot generate an Image.

If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.

Parameters

context	GPU Context
backendTexture	texture residing on GPU
origin	one of: kBottomLeft GrSurfaceOrigin, kTopLeft GrSurfaceOrigin
sampleCnt	samples per pixel, or 0 to disable full scene anti-aliasing
colorType	one of: kUnknown_SkColorType, kAlpha_8_SkColorType, kRGB_565_SkColorType, kARGB_4444_SkColorType, kRGBA_8888_SkColorType, kRGB_888x_SkColorType, kBGRA_8888_SkColorType, kRGBA_1010102_SkColorType, kRGB_101010x_SkColorType, kGray_8_SkColorType, kRGBA_F16_SkColorType
colorSpace	range of colors; may be nullptr
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

See Also

MakeFromBackendRenderTarget MakeRenderTarget^[2][3][4]

---

MakeRenderTarget

static sk sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted,
                                         const SkImageInfo& imageInfo, int sampleCount,
                                         GrSurfaceOrigin surfaceOrigin,
                                         const SkSurfaceProps* surfaceProps,
                                         bool shouldCreateWithMips = false)

Returns Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Color Type in ImageInfo. budgeted selects whether allocation for pixels is tracked by context. imageInfo describes the pixel format in Color Type, and transparency in Alpha Type, and color matching in Color Space.

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 Image returned by makeImageSnapshot is Mip_Map.

If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.

Parameters

context	GPU Context
budgeted	one of: SkBudgeted::kNo, SkBudgeted::kYes
imageInfo	width, height, Color Type, Alpha Type, Color Space; width, or height, or both, may be zero
sampleCount	samples per pixel, or 0 to disable full scene anti-aliasing
surfaceOrigin	one of: kBottomLeft GrSurfaceOrigin, kTopLeft GrSurfaceOrigin
surfaceProps	LCD striping orientation and setting for device independent fonts; may be nullptr
shouldCreateWithMips	hint that Surface will host Mip_Map images

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

See Also

MakeFromBackendRenderTarget MakeFromBackendTextureAsRenderTarget

---

static sk sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted,
                                         const SkImageInfo& imageInfo, int sampleCount,
                                         const SkSurfaceProps* props)

Returns Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Color Type in ImageInfo. budgeted selects whether allocation for pixels is tracked by context. imageInfo describes the pixel format in Color Type, and transparency in Alpha Type, and color matching in Color Space.

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.

Surface bottom-left corner is pinned to the origin.

Parameters

context	GPU Context
budgeted	one of: SkBudgeted::kNo, SkBudgeted::kYes
imageInfo	width, height, Color Type, Alpha Type, Color Space, of Raster Surface; width, or height, or both, may be zero
sampleCount	samples per pixel, or 0 to disable Multi_Sample_Anti_Aliasing
props	LCD striping orientation and setting for device independent fonts; may be nullptr

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

LCD text takes advantage of raster striping to improve resolution. Only one of the four combinations is correct, depending on whether monitor LCD striping is horizontal or vertical, and whether the order of the stripes is red blue green or red green blue.

See Also

MakeFromBackendRenderTarget MakeFromBackendTextureAsRenderTarget

---

static sk sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted,
                                         const SkImageInfo& imageInfo)

Returns Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Color Type in ImageInfo. budgeted selects whether allocation for pixels is tracked by context. imageInfo describes the pixel format in Color Type, and transparency in Alpha Type, and color matching in Color Space.

Surface bottom-left corner is pinned to the origin.

Parameters

context	GPU Context
budgeted	one of: SkBudgeted::kNo, SkBudgeted::kYes
imageInfo	width, height, Color Type, Alpha Type, Color Space, of Raster Surface; width, or height, or both, may be zero

Return Value

Surface if all parameters are valid; otherwise, nullptr

Example

See Also

MakeFromBackendRenderTarget MakeFromBackendTextureAsRenderTarget

---

static sk sp<SkSurface> MakeRenderTarget(GrContext* context,
                                         const SkSurfaceCharacterization& characterization,
                                         SkBudgeted 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
budgeted	one of: SkBudgeted::kNo, SkBudgeted::kYes

Return Value

Surface if all parameters are valid; otherwise, nullptr

See Also

MakeFromBackendRenderTarget MakeFromBackendTextureAsRenderTarget

---

MakeNull

static sk sp<SkSurface> MakeNull(int width, int height)

Returns Surface without backing pixels. Drawing to Canvas returned from Surface has no effect. Calling makeImageSnapshot on returned Surface returns nullptr.

Parameters

width	one or greater
height	one or greater

Return Value

Surface if width and height are positive; otherwise, nullptr

Example

Example Output

SkSurface::MakeNull(0, 0) == nullptr
surf->makeImageSnapshot() == nullptr

See Also

MakeRaster^[2] MakeRenderTarget^[2][3][4]

---

Property

Topic	Description
generationID	returns unique ID
getBackendRenderTarget	returns the GPU reference to render target
getBackendTexture	returns the GPU reference to texture
getCanvas	returns Canvas that draws into Surface
height	returns pixel row count
props	returns Surface Properties
width	returns pixel column count

width

int width() const

Returns pixel count in each row; may be zero or greater.

Return Value

number of pixel columns

Example

Example Output

surface width=37  canvas width=37

See Also

height

---

height

int height() const

Returns pixel row count; may be zero or greater.

Return Value

number of pixel rows

Example

Example Output

surface height=1000  canvas height=1000

See Also

width

---

generationID

uint32_t generationID()

Returns unique value identifying the content of Surface. Returned value changes each time the content changes. Content is changed by drawing, or by calling notifyContentWillChange.

Return Value

unique content identifier

Example

Example Output

surface generationID: 1
surface generationID: 2
surface generationID: 3

See Also

notifyContentWillChange ContentChangeMode getCanvas

---

Enum SkSurface::ContentChangeMode

    enum ContentChangeMode {
        kDiscard ContentChangeMode,
        kRetain ContentChangeMode,
    };

ContentChangeMode members are parameters to notifyContentWillChange.

Constants

Const	Value	Description
SkSurface::kDiscard_ContentChangeMode	#Line # discards surface on change ##	Pass to notifyContentWillChange to discard surface contents when the surface is cleared or overwritten.
SkSurface::kRetain_ContentChangeMode	#Line # preserves surface on change ##	Pass to notifyContentWillChange when to preserve surface contents. If a snapshot has been generated, this copies the Surface contents.

See Also

notifyContentWillChange generationID

Miscellaneous

Topic	Description
notifyContentWillChange	notifies that contents will be changed outside of Skia

notifyContentWillChange

void notifyContentWillChange(ContentChangeMode mode)

Notifies that Surface contents will be changed by code outside of Skia. Subsequent calls to generationID return a different value.

mode is normally passed as kRetain ContentChangeMode.

Can we deprecate this?

Parameters

mode	one of: kDiscard ContentChangeMode, kRetain ContentChangeMode

Example

See Also

ContentChangeMode generationID

---

Enum SkSurface::BackendHandleAccess

    enum BackendHandleAccess {
        kFlushRead BackendHandleAccess,
        kFlushWrite BackendHandleAccess,
        kDiscardWrite BackendHandleAccess,
    };

    static const BackendHandleAccess kFlushRead TextureHandleAccess =
            kFlushRead BackendHandleAccess;
    static const BackendHandleAccess kFlushWrite TextureHandleAccess =
            kFlushWrite BackendHandleAccess;
    static const BackendHandleAccess kDiscardWrite TextureHandleAccess =
            kDiscardWrite BackendHandleAccess;

Constants

Const	Value	Description
SkSurface::kFlushRead_BackendHandleAccess	0	Caller may read from the back-end object.
SkSurface::kFlushWrite_BackendHandleAccess	1	Caller may write to the back-end object.
SkSurface::kDiscardWrite_BackendHandleAccess	2	Caller must overwrite the entire back-end object.
SkSurface::kFlushRead_TextureHandleAccess	0	Deprecated.
SkSurface::kFlushWrite_TextureHandleAccess	1	Deprecated.
SkSurface::kDiscardWrite_TextureHandleAccess	2	Deprecated.

See Also

getBackendTexture getBackendRenderTarget

getBackendTexture

GrBackendTexture getBackendTexture(BackendHandleAccess backendHandleAccess)

Retrieves the back-end texture. If Surface 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 Surface is drawn to or deleted.

Parameters

backendHandleAccess

one of: kFlushRead BackendHandleAccess, kFlushWrite BackendHandleAccess, kDiscardWrite BackendHandleAccess

Return Value

GPU texture reference; invalid on failure

See Also

GrBackendTexture BackendHandleAccess getBackendRenderTarget

---

getBackendRenderTarget

GrBackendRenderTarget getBackendRenderTarget(BackendHandleAccess backendHandleAccess)

Retrieves the back-end render target. If Surface 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 Surface is drawn to or deleted.

Parameters

backendHandleAccess

one of: kFlushRead BackendHandleAccess, kFlushWrite BackendHandleAccess, kDiscardWrite BackendHandleAccess

Return Value

GPU render target reference; invalid on failure

See Also

GrBackendRenderTarget BackendHandleAccess getBackendTexture

---

getCanvas

SkCanvas* getCanvas()

Returns Canvas that draws into Surface. Subsequent calls return the same Canvas. Canvas returned is managed and owned by Surface, and is deleted when Surface is deleted.

Return Value

drawing Canvas for Surface

Example

See Also

makeSurface makeImageSnapshot draw^[2]

---

makeSurface

sk sp<SkSurface> makeSurface(const SkImageInfo& imageInfo)

Returns a compatible Surface, or nullptr. Returned Surface contains the same raster, GPU, or null properties as the original. Returned Surface does not share the same pixels.

Returns nullptr if imageInfo width or height are zero, or if imageInfo is incompatible with Surface.

Parameters

imageInfo

width, height, Color Type, Alpha Type, Color Space, of Surface; width and height must be greater than zero

Return Value

compatible Surface or nullptr

Example

See Also

makeImageSnapshot getCanvas draw^[2]

---

makeImageSnapshot

sk sp<SkImage> makeImageSnapshot()

Returns Image capturing Surface contents. Subsequent drawing to Surface contents are not captured. Image allocation is accounted for if Surface was created with SkBudgeted::kYes.

Return Value

Image initialized with Surface contents

Example

See Also

draw^[2] getCanvas

---

Pixels

Topic	Description
draw	draws Surface contents to canvas
	draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint)
	draw(SkDeferredDisplayList* deferredDisplayList)
peekPixels	copies Surface parameters to Pixmap
readPixels	copies Rect of pixels
	readPixels(const SkPixmap& dst, int srcX, int srcY)
	readPixels(const SkImageInfo& dstInfo, void* dstPixels, size t dstRowBytes, int srcX, int srcY)
	readPixels(const SkBitmap& dst, int srcX, int srcY)
writePixels	copies Rect of pixels
	writePixels(const SkPixmap& src, int dstX, int dstY)
	writePixels(const SkBitmap& src, int dstX, int dstY)

draw

void draw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint)

Draws Surface contents to canvas, with its top-left corner at (x, y).

If Paint paint is not nullptr, apply Color Filter, Color Alpha, Image Filter, Blend Mode, and Draw Looper.

Parameters

canvas	Canvas drawn into
x	horizontal offset in Canvas
y	vertical offset in Canvas
paint	Paint containing Blend Mode, Color Filter, Image Filter, and so on; or nullptr

Example

See Also

makeImageSnapshot getCanvas

---

peekPixels

bool peekPixels(SkPixmap* pixmap)

Copies Surface pixel address, row bytes, and Image Info to Pixmap, if address is available, and returns true. If pixel address is not available, return false and leave Pixmap unchanged.

pixmap contents become invalid on any future change to Surface.

Parameters

pixmap

storage for pixel state if pixels are readable; otherwise, ignored

Return Value

true if Surface has direct access to pixels

Example

See Also

readPixels^[2][3] writePixels^[2]

---

readPixels

bool readPixels(const SkPixmap& dst, int srcX, int srcY)

Copies Rect of pixels to dst.

Source Rect corners are (srcX, srcY) and Surface (width, height). Destination Rect corners are (0, 0) and (dst.width, dst.height). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst.colorType() and dst.alphaType() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. dst contents outside Rect intersection are unchanged.

Pass negative values for srcX or srcY to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.

Pixmap pixels could not be allocated.

dst.rowBytes() is too small to contain one row of pixels.

Parameters

dst	storage for pixels copied from Surface
srcX	offset into readable pixels in x; may be negative
srcY	offset into readable pixels in y; may be negative

Return Value

true if pixels were copied

Example

See Also

peekPixels writePixels^[2]

---

bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes, int srcX, int srcY)

Copies Rect of pixels from Canvas into dstPixels.

Source Rect corners are (srcX, srcY) and Surface (width, height). Destination Rect corners are (0, 0) and (dstInfo.width, dstInfo.height). Copies each readable pixel intersecting both rectangles, without scaling, converting to dstInfo.colorType() and dstInfo.alphaType() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. dstPixels contents outside Rect intersection are unchanged.

Pass negative values for srcX or srcY to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.

Surface pixels could not be converted to dstInfo.colorType() or dstInfo.alphaType().

dstRowBytes is too small to contain one row of pixels.

Parameters

dstInfo	width, height, Color Type, and Alpha Type of dstPixels
dstPixels	storage for pixels; dstInfo.height times dstRowBytes, or larger
dstRowBytes	size of one destination row; dstInfo.width times pixel size, or larger
srcX	offset into readable pixels in x; may be negative
srcY	offset into readable pixels in y; may be negative

Return Value

true if pixels were copied

Example

A black oval drawn on a red background provides an image to copy. readPixels copies one quarter of the Surface into each of the four corners. The copied quarter ovals overdraw the original oval.

See Also

peekPixels writePixels^[2]

---

bool readPixels(const SkBitmap& dst, int srcX, int srcY)

Copies Rect of pixels from Surface into bitmap.

Source Rect corners are (srcX, srcY) and Surface (width, height). Destination Rect corners are (0, 0) and (bitmap.width, bitmap.height). Copies each readable pixel intersecting both rectangles, without scaling, converting to bitmap.colorType() and bitmap.alphaType() if required.

Pixels are readable when Surface is raster, or backed by a GPU.

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if Color Type and Alpha Type do not match. Only pixels within both source and destination rectangles are copied. dst contents outside Rect intersection are unchanged.

Pass negative values for srcX or srcY to offset pixels across or down destination.

Does not copy, and returns false if:

Source and destination rectangles do not intersect.

Surface pixels could not be converted to dst.colorType() or dst.alphaType().

dst pixels could not be allocated.

dst.rowBytes() is too small to contain one row of pixels.

Parameters

dst	storage for pixels copied from Surface
srcX	offset into readable pixels in x; may be negative
srcY	offset into readable pixels in y; may be negative

Return Value

true if pixels were copied

Example

See Also

peekPixels writePixels^[2]

---

writePixels

void writePixels(const SkPixmap& src, int dstX, int dstY)

Copies Rect of pixels from the src Pixmap to the Surface.

Source Rect corners are (0, 0) and (src.width, src.height). Destination Rect corners are (dstX, dstY) and(dstX + Surface width, dstY + Surface height) .

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface colorType() and Surface alphaType() if required.

Parameters

src	storage for pixels to copy to Surface
dstX	x position relative to Surface to begin copy; may be negative
dstY	x position relative to Surface to begin copy; may be negative

Example

See Also

readPixels^[2][3] peekPixels

---

void writePixels(const SkBitmap& src, int dstX, int dstY)

Copies Rect of pixels from the src Bitmap to the Surface.

Source Rect corners are (0, 0) and (src.width, src.height). Destination Rect corners are (dstX, dstY) and(dstX + Surface width, dstY + Surface height) .

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface colorType() and Surface alphaType() if required.

Parameters

src	storage for pixels to copy to Surface
dstX	x position relative to Surface to begin copy; may be negative
dstY	x position relative to Surface to begin copy; may be negative

Example

See Also

readPixels^[2][3] peekPixels

---

props

const SkSurfaceProps& props() const

Returns Surface Properties for surface.

Return Value

LCD striping orientation and setting for device independent fonts

Example

Example Output

surf.props(): kRGB_H_SkPixelGeometry

See Also

SkSurfaceProps

---

prepareForExternalIO

void prepareForExternalIO()

Deprecated.

soon

---

Utility

Topic	Description
characterize	sets Surface Characterization for threaded GPU processing
flush	resolves pending I/O
flushAndSignalSemaphores	resolves pending I/O, and signal
wait	pauses commands until signaled

flush

void flush()

Issues pending Surface commands to the GPU-backed API and resolves any Surface MSAA.

Skia flushes as needed, so it is not necessary to call this if Skia manages drawing and object lifetime. Call when interleaving Skia calls with native GPU calls.

See Also

GrBackendSemaphore

---

flushAndSignalSemaphores

GrSemaphoresSubmitted flushAndSignalSemaphores(int numSemaphores,
                                               GrBackendSemaphore signalSemaphores[])

Issues pending Surface commands to the GPU-backed API and resolves any Surface MSAA. After issuing all commands, signalSemaphores of count numSemaphores semaphores are signaled by the GPU.

For each GrBackendSemaphore in signalSemaphores: if GrBackendSemaphore is initialized, the GPU back-end uses the semaphore as is; otherwise, a new semaphore is created and initializes GrBackendSemaphore.

The caller must delete the semaphores created and returned in signalSemaphores. GrBackendSemaphore can be deleted as soon as this function returns.

If the back-end API is OpenGL only uninitialized Backend Semaphores are supported.

If the back-end API is Vulkan semaphores may be initialized or uninitialized. If uninitialized, created semaphores are valid only with the VkDevice with which they were created.

If GrSemaphoresSubmitted::kNo is returned, the GPU back-end did not create or add any semaphores to signal on the GPU; the caller should not instruct the GPU to wait on any of the semaphores.

Pending surface commands are flushed regardless of the return result.

Parameters

numSemaphores	size of signalSemaphores array
signalSemaphores	array of semaphore containers

Return Value

one of: GrSemaphoresSubmitted::kYes, GrSemaphoresSubmitted::kNo

See Also

wait GrBackendSemaphore

---

wait

bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores)

Inserts a list of GPU semaphores that the current GPU-backed API must wait on before executing any more commands on the GPU for this surface. Skia will take ownership of the underlying semaphores and delete them once they have been signaled and waited on. If this call returns false, then the GPU back-end will not wait on any passed in semaphores, and the client will still own the semaphores.

Parameters

numSemaphores	size of waitSemaphores array
waitSemaphores	array of semaphore containers

Return Value

true if GPU is waiting on semaphores

See Also

flushAndSignalSemaphores GrBackendSemaphore

---

characterize

bool characterize(SkSurfaceCharacterization* characterization) const

Initializes Surface Characterization that can be used to perform GPU back-end processing in a separate thread. Typically this is used to divide drawing into multiple tiles. DeferredDisplayListRecorder records the drawing commands for each tile.

Return true if Surface supports characterization. Raster Surface returns false.

Parameters

characterization

properties for parallel drawing

Return Value

true if supported

Example

See Also

draw^[2] SkSurfaceCharacterization SkDeferredDisplayList

---

bool draw(SkDeferredDisplayList* deferredDisplayList)

Draws deferred display list created using SkDeferredDisplayListRecorder. Has no effect and returns false if Surface Characterization stored in deferredDisplayList is not compatible with Surface.

Raster Surface returns false.

Parameters

deferredDisplayList

drawing commands

Return Value

false if deferredDisplayList is not compatible

Example

See Also

characterize SkSurfaceCharacterization SkDeferredDisplayList

---