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 ## Subtopics | topics | description | | --- | --- | ## Member Functions | description | function | | --- | --- | | MakeFromBackendRenderTarget | Creates Surface from GPU memory buffer. | | MakeFromBackendTexture | Creates Surface from GPU-backed texture. | | MakeFromBackendTextureAsRenderTarget | Creates Surface from GPU-backed texture. | | 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 | Set up Surface Characterization for threaded pre-processing. | | draw | Draws Surface contents to canvas. | | flush | Resolve pending I/O. | | flushAndSignalSemaphores | Resolve pending I/O, and signal. | | generationID | Returns unique ID. | | getCanvas | Returns Canvas that draws into Surface. | | getRenderTargetHandle | Returns the GPU reference to render target. | | getTextureHandle | Returns the GPU reference to texture. | | height | Returns pixel row count. | | makeImageSnapshot | Returns Image capturing Surface contents. | | makeSurface | Returns a compatible Surface. | | notifyContentWillChange | Notifies that contents will be changed outside of Skia. | | peekPixels | Copies Surface parameters to Pixmap. | | prepareForExternalIO | To be deprecated. | | props | Returns Surface Properties. | | readPixels | Copies Rect of pixels. | | wait | Pause commands until signaled. | | width | Returns pixel column count. | ## 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 Image Color Type and Image Alpha Type supported by Raster Surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of Image 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, Image Color Type, Image 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 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 Image Color Type and Image Alpha Type supported by Raster Surface; pixels is not nullptr; rowBytes is large enough to contain info width pixels of Image 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, Image Color Type, Image 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 --- ## 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 Image Color Type and Image Alpha Type supported by Raster Surface; rowBytes is large enough to contain info width pixels of Image Color Type, or is zero. If rowBytes is not zero, subsequent images returned by makeImageSnapshot have the same rowBytes. ### Parameters
imageInfo width, height, Image Color Type, Image 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 Image Color Type and Image Alpha Type supported by Raster Surface. ### Parameters
imageInfo width, height, Image Color Type, Image 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,
                                               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
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 
void draw(SkCanvas* canvas) {
    SkPaint paint;
    paint.setTextSize(32);
    GrContext* context = canvas->getGrContext();
    if (!context) {
         canvas->drawString("GPU only!", 20, 40, paint);
         return;
    }
    sk_sp gpuSurface = SkSurface::MakeFromBackendTexture(context,
            backEndTextureRenderTarget, kTopLeft_GrSurfaceOrigin, 0, nullptr, nullptr);
    auto surfaceCanvas = gpuSurface->getCanvas();
    surfaceCanvas->clear(SK_ColorWHITE);
    surfaceCanvas->drawString("GPU rocks!", 20, 40, paint);
    sk_sp image(gpuSurface->makeImageSnapshot());
    canvas->drawImage(image, 0, 0);
}
### See Also GrBackendTexture MakeFromBackendRenderTarget MakeRenderTarget --- ## MakeFromBackendRenderTarget 
static sk_sp<SkSurface> MakeFromBackendRenderTarget(GrContext* context,
                                                   const GrBackendRenderTarget& backendRenderTarget,
                                                   GrSurfaceOrigin origin,
                                                   sk_sp<SkColorSpace> colorSpace,
                                                   const SkSurfaceProps* surfaceProps)
Wraps a GPU-backed buffer into Surface. Caller must ensure render target 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
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 
void draw(SkCanvas* canvas) {
    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, nullptr, nullptr);
    auto surfaceCanvas = gpuSurface->getCanvas();
    surfaceCanvas->clear(SK_ColorWHITE);
    surfaceCanvas->drawString("GPU rocks!", 20, 40, paint);
    sk_sp image(gpuSurface->makeImageSnapshot());
    canvas->drawImage(image, 0, 0);
}
### See Also MakeFromBackendTexture MakeRenderTarget --- ## MakeFromBackendTextureAsRenderTarget 
static sk_sp<SkSurface> MakeFromBackendTextureAsRenderTarget(GrContext* context,
                                            const GrBackendTexture& backendTexture,
                                            GrSurfaceOrigin origin, int sampleCnt,
                                            sk_sp<SkColorSpace> colorSpace,
                                            const SkSurfaceProps* surfaceProps)
Used to wrap a GPU-backed texture as a SkSurface. Skia will treat the texture as a rendering target only, but unlike NewFromBackendRenderTarget, Skia will manage and own the associated render target objects (but not the provided texture). Skia will not assume ownership of the texture and the client must ensure the texture is valid for the lifetime of the SkSurface. 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
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 
void draw(SkCanvas* canvas) {SkPaint paint;
    paint.setTextSize(32);
    GrContext* context = canvas->getGrContext();
    if (!context) {
         canvas->drawString("GPU only!", 20, 40, paint);
         return;
    }
    sk_sp gpuSurface = SkSurface::MakeFromBackendTextureAsRenderTarget(
            context, backEndTextureRenderTarget, kTopLeft_GrSurfaceOrigin, 0,
            nullptr, nullptr);
    auto surfaceCanvas = gpuSurface->getCanvas();
    surfaceCanvas->clear(SK_ColorWHITE);
    surfaceCanvas->drawString("GPU rocks!", 20, 40, paint);
    sk_sp image(gpuSurface->makeImageSnapshot());
    canvas->drawImage(image, 0, 0);
}
### See Also MakeFromBackendRenderTarget MakeRenderTarget --- ## MakeRenderTarget 
static sk_sp<SkSurface> MakeRenderTarget(GrContext* context, SkBudgeted budgeted,
                                         const SkImageInfo& imageInfo, int sampleCount,
                                         GrSurfaceOrigin surfaceOrigin,
                                         const SkSurfaceProps* surfaceProps,
                                         bool shouldCreateWithMips = false)
Returns offscreen Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Image Color Type in ImageInfo. budgeted selects whether allocation for offscreen pixels is tracked by context. imageInfo describes the pixel format in Image Color Type, and transparency in Image 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, Image Color Type, Image 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 offscreen Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Image Color Type in ImageInfo. budgeted selects whether allocation for offscreen pixels is tracked by context. imageInfo describes the pixel format in Image Color Type, and transparency in Image 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, Image Color Type, Image 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 the monitor's LCD 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 offscreen Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and Image Color Type in ImageInfo. budgeted selects whether allocation for offscreen pixels is tracked by context. imageInfo describes the pixel format in Image Color Type, and transparency in Image 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, Image Color Type, Image 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 --- ## 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 MakeRenderTarget --- ## 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
SkSurface::kDiscard_ContentChangeMode Pass to notifyContentWillChange to discard surface contents whenthe surface is cleared or overwritten.
SkSurface::kRetain_ContentChangeMode Pass to notifyContentWillChange when to preserve surface contents.If a snapshot has been generated, this copies the Surface contents.
### See Also notifyContentWillChange generationID ## 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. ### Parameters
mode one of: kDiscard ContentChangeMode, kRetain ContentChangeMode
### Example
### See Also ContentChangeMode generationID --- ## Enum SkSurface::BackendHandleAccess 
enum BackendHandleAccess {
kFlushRead BackendHandleAccess,
kFlushWrite BackendHandleAccess,
kDiscardWrite BackendHandleAccess,
};
### Constants
SkSurface::kFlushRead_BackendHandleAccess 0Caller may read from the back-end object.
SkSurface::kFlushWrite_BackendHandleAccess 1Caller may write to the back-end object.
SkSurface::kDiscardWrite_BackendHandleAccess 2Caller must overwrite the entire back-end object.
### Example
### See Also getTextureHandle getRenderTargetHandle ## getTextureHandle 
GrBackendObject getTextureHandle(BackendHandleAccess backendHandleAccess)
Returns the GPU back-end reference of the texture used by Surface, or zero if Surface is not backed by a GPU texture. The returned texture handle is only valid until the next draw into Surface, or when Surface is deleted. ### Parameters
backendHandleAccess one of: kFlushRead BackendHandleAccess, kFlushWrite BackendHandleAccess, kDiscardWrite BackendHandleAccess
### Return Value GPU texture reference ### Example
### See Also getRenderTargetHandle GrBackendObject BackendHandleAccess --- ## getRenderTargetHandle 
bool getRenderTargetHandle(GrBackendObject* backendObject, BackendHandleAccess backendHandleAccess)
Returns true and stores the GPU back-end reference of the render target used by Surface in backendObject. Return false if Surface is not backed by a GPU render target, and leaves backendObject unchanged. The returned render target handle is only valid until the next draw into Surface, or when Surface is deleted. In OpenGL this returns the frame buffer object ID. ### Parameters
backendObject GPU intermediate memory buffer
backendHandleAccess one of: kFlushRead BackendHandleAccess, kFlushWrite BackendHandleAccess, kDiscardWrite BackendHandleAccess
### Return Value true if Surface is backed by GPU texture ### Example
### See Also getTextureHandle GrBackendObject BackendHandleAccess --- ## 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 --- ## 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, Image Color Type, Image 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 --- ## 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 getCanvas --- ## 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 --- ## readPixels 
bool readPixels(const SkPixmap& dst, int srcX, int srcY)
Copies Rect of pixels to dst. Source Rect corners are (srcX, srcY) and (this->width, this->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 Image Color Type and Image 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 --- 
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 (this->width, this->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 Image Color Type and Image 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, Image Color Type, and Image 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 --- 
bool readPixels(const SkBitmap& dst, int srcX, int srcY)
Copies Rect of pixels from Surface into bitmap. Source Rect corners are (srcX, srcY) and (this->width, this->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 Image Color Type and Image 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 --- ## 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()
To be deprecated. --- ## 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 GrBackendSemaphores 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 ### Example
### See Also flushAndSignalSemaphores GrBackendSemaphore --- ## characterize 
bool characterize(SkSurfaceCharacterization* characterization) const
Initializes Surface Characterization that can be used to perform GPU back-end pre-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 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 ---