 |
Skia
2D Graphics Library
|
|
Skia
2D Graphics Library
|
#include <SkSurface.h>
Public Member Functions | |
| bool | isCompatible (const SkSurfaceCharacterization &characterization) const |
| Is this surface compatible with the provided characterization? More... | |
| int | width () const |
| Returns pixel count in each row; may be zero or greater. More... | |
| int | height () const |
| Returns pixel row count; may be zero or greater. More... | |
| SkImageInfo | imageInfo () |
| Returns an ImageInfo describing the surface. More... | |
| uint32_t | generationID () |
| Returns unique value identifying the content of SkSurface. More... | |
| void | notifyContentWillChange (ContentChangeMode mode) |
| Notifies that SkSurface contents will be changed by code outside of Skia. More... | |
| GrRecordingContext * | recordingContext () |
| Returns the recording context being used by the SkSurface. More... | |
| GrBackendTexture | getBackendTexture (BackendHandleAccess backendHandleAccess) |
| Retrieves the back-end texture. More... | |
| GrBackendRenderTarget | getBackendRenderTarget (BackendHandleAccess backendHandleAccess) |
| Retrieves the back-end render target. More... | |
| bool | replaceBackendTexture (const GrBackendTexture &backendTexture, GrSurfaceOrigin origin, ContentChangeMode mode=kRetain_ContentChangeMode, TextureReleaseProc textureReleaseProc=nullptr, ReleaseContext releaseContext=nullptr) |
| If the surface was made via MakeFromBackendTexture then it's backing texture may be substituted with a different texture. More... | |
| SkCanvas * | getCanvas () |
| Returns SkCanvas that draws into SkSurface. More... | |
| sk_sp< SkSurface > | makeSurface (const SkImageInfo &imageInfo) |
| Returns a compatible SkSurface, or nullptr. More... | |
| sk_sp< SkSurface > | makeSurface (int width, int height) |
| Calls makeSurface(ImageInfo) with the same ImageInfo as this surface, but with the specified width and height. More... | |
| sk_sp< SkImage > | makeImageSnapshot () |
| Returns SkImage capturing SkSurface contents. More... | |
| sk_sp< SkImage > | makeImageSnapshot (const SkIRect &bounds) |
| Like the no-parameter version, this returns an image of the current surface contents. More... | |
| void | draw (SkCanvas *canvas, SkScalar x, SkScalar y, const SkSamplingOptions &sampling, const SkPaint *paint) |
| Draws SkSurface contents to canvas, with its top-left corner at (x, y). More... | |
| void | draw (SkCanvas *canvas, SkScalar x, SkScalar y) |
| void | draw (SkCanvas *canvas, SkScalar x, SkScalar y, const SkPaint *paint) |
| bool | peekPixels (SkPixmap *pixmap) |
| Copies SkSurface pixel address, row bytes, and SkImageInfo to SkPixmap, if address is available, and returns true. More... | |
| bool | readPixels (const SkPixmap &dst, int srcX, int srcY) |
| Copies SkRect of pixels to dst. More... | |
| bool | readPixels (const SkImageInfo &dstInfo, void *dstPixels, size_t dstRowBytes, int srcX, int srcY) |
| Copies SkRect of pixels from SkCanvas into dstPixels. More... | |
| bool | readPixels (const SkBitmap &dst, int srcX, int srcY) |
| Copies SkRect of pixels from SkSurface into bitmap. More... | |
| void | asyncRescaleAndReadPixels (const SkImageInfo &info, const SkIRect &srcRect, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) |
| Makes surface pixel data available to caller, possibly asynchronously. More... | |
| void | asyncRescaleAndReadPixelsYUV420 (SkYUVColorSpace yuvColorSpace, sk_sp< SkColorSpace > dstColorSpace, const SkIRect &srcRect, const SkISize &dstSize, RescaleGamma rescaleGamma, RescaleMode rescaleMode, ReadPixelsCallback callback, ReadPixelsContext context) |
| Similar to asyncRescaleAndReadPixels but performs an additional conversion to YUV. More... | |
| void | writePixels (const SkPixmap &src, int dstX, int dstY) |
| Copies SkRect of pixels from the src SkPixmap to the SkSurface. More... | |
| void | writePixels (const SkBitmap &src, int dstX, int dstY) |
| Copies SkRect of pixels from the src SkBitmap to the SkSurface. More... | |
| const SkSurfaceProps & | props () const |
| Returns SkSurfaceProps for surface. More... | |
| void | flushAndSubmit (bool syncCpu=false) |
| Call to ensure all reads/writes of the surface have been issued to the underlying 3D API. More... | |
| GrSemaphoresSubmitted | flush (BackendSurfaceAccess access, const GrFlushInfo &info) |
| Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA. More... | |
| GrSemaphoresSubmitted | flush (const GrFlushInfo &info, const GrBackendSurfaceMutableState *newState=nullptr) |
| Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA. More... | |
| void | flush () |
| bool | wait (int numSemaphores, const GrBackendSemaphore *waitSemaphores, bool deleteSemaphoresAfterWait=true) |
| 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. More... | |
| bool | characterize (SkSurfaceCharacterization *characterization) const |
| Initializes SkSurfaceCharacterization that can be used to perform GPU back-end processing in a separate thread. More... | |
| bool | draw (sk_sp< const SkDeferredDisplayList > deferredDisplayList, int xOffset=0, int yOffset=0) |
| Draws the deferred display list created via a SkDeferredDisplayListRecorder. More... | |
| bool | unique () const |
| May return true if the caller is the only owner. More... | |
| void | ref () const |
| Increment the reference count. More... | |
| void | unref () const |
| Decrement the reference count. More... | |
Static Public Member Functions | |
| static sk_sp< SkSurface > | MakeRasterDirect (const SkImageInfo &imageInfo, void *pixels, size_t rowBytes, const SkSurfaceProps *surfaceProps=nullptr) |
| Allocates raster SkSurface. More... | |
| static sk_sp< SkSurface > | MakeRasterDirect (const SkPixmap &pm, const SkSurfaceProps *props=nullptr) |
| 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 SkSurface. More... | |
| static sk_sp< SkSurface > | MakeRaster (const SkImageInfo &imageInfo, size_t rowBytes, const SkSurfaceProps *surfaceProps) |
| Allocates raster SkSurface. More... | |
| static sk_sp< SkSurface > | MakeRaster (const SkImageInfo &imageInfo, const SkSurfaceProps *props=nullptr) |
| Allocates raster SkSurface. More... | |
| static sk_sp< SkSurface > | MakeRasterN32Premul (int width, int height, const SkSurfaceProps *surfaceProps=nullptr) |
| Allocates raster SkSurface. More... | |
| static sk_sp< SkSurface > | MakeFromBackendTexture (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. More... | |
| static sk_sp< SkSurface > | MakeFromBackendRenderTarget (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. More... | |
| static sk_sp< SkSurface > | MakeRenderTarget (GrRecordingContext *context, SkBudgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false) |
| Returns SkSurface on GPU indicated by context. More... | |
| static sk_sp< SkSurface > | MakeRenderTarget (GrRecordingContext *context, SkBudgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, const SkSurfaceProps *surfaceProps) |
| Returns SkSurface on GPU indicated by context. More... | |
| static sk_sp< SkSurface > | MakeRenderTarget (GrRecordingContext *context, SkBudgeted budgeted, const SkImageInfo &imageInfo) |
| Returns SkSurface on GPU indicated by context. More... | |
| static sk_sp< SkSurface > | MakeRenderTarget (GrRecordingContext *context, const SkSurfaceCharacterization &characterization, SkBudgeted budgeted) |
| Returns SkSurface on GPU indicated by context that is compatible with the provided characterization. More... | |
| static sk_sp< SkSurface > | MakeNull (int width, int height) |
| Returns SkSurface without backing pixels. More... | |
Static Public Attributes | |
| static const BackendHandleAccess | kFlushRead_TextureHandleAccess |
| Deprecated. More... | |
| static const BackendHandleAccess | kFlushWrite_TextureHandleAccess |
| Deprecated. More... | |
| static const BackendHandleAccess | kDiscardWrite_TextureHandleAccess |
| Deprecated. More... | |
Protected Member Functions | |
| SkSurface (int width, int height, const SkSurfaceProps *surfaceProps) | |
| SkSurface (const SkImageInfo &imageInfo, const SkSurfaceProps *surfaceProps) | |
| void | dirtyGenerationID () |
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.
| using SkSurface::ReadPixelsCallback = void(ReadPixelsContext, std::unique_ptr<const AsyncReadResult>) |
Client-provided callback to asyncRescaleAndReadPixels() or asyncRescaleAndReadPixelsYUV420() that is called when read result is ready or on failure.
| using SkSurface::ReadPixelsContext = void* |
Client-provided context that is passed to client-provided ReadPixelsContext.
| typedef void* SkSurface::ReleaseContext |
Caller data passed to RenderTarget/TextureReleaseProc; may be nullptr.
| typedef void(* SkSurface::RenderTargetReleaseProc) (ReleaseContext releaseContext) |
User function called when supplied render target may be deleted.
Controls the gamma that rescaling occurs in for asyncRescaleAndReadPixels() and asyncRescaleAndReadPixelsYUV420().
| typedef void(* SkSurface::TextureReleaseProc) (ReleaseContext releaseContext) |
User function called when supplied texture may be deleted.
|
strong |
|
protected |
|
protected |
| void SkSurface::asyncRescaleAndReadPixels | ( | const SkImageInfo & | info, |
| const SkIRect & | srcRect, | ||
| RescaleGamma | rescaleGamma, | ||
| RescaleMode | rescaleMode, | ||
| ReadPixelsCallback | callback, | ||
| ReadPixelsContext | context | ||
| ) |
Makes surface pixel data available to caller, possibly asynchronously.
It can also rescale the surface pixels.
Currently asynchronous reads are only supported on the GPU backend and only when the underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all other cases this operates synchronously.
Data is read from the source sub-rectangle, is optionally converted to a linear gamma, is rescaled to the size indicated by 'info', is then converted to the color space, color type, and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the surface causes failure.
When the pixel data is ready the caller's ReadPixelsCallback is called with a AsyncReadResult containing pixel data in the requested color type, alpha type, and color space. The AsyncReadResult will have count() == 1. Upon failure the callback is called with nullptr for AsyncReadResult. For a GPU surface this flushes work but a submit must occur to guarantee a finite time before the callback is called.
The data is valid for the lifetime of AsyncReadResult with the exception that if the SkSurface is GPU-backed the data is immediately invalidated if the context is abandoned or destroyed.
| info | info of the requested pixels |
| srcRect | subrectangle of surface to read |
| rescaleGamma | controls whether rescaling is done in the surface's gamma or whether the source data is transformed to a linear gamma before rescaling. |
| rescaleMode | controls the technique of the rescaling |
| callback | function to call with result of the read |
| context | passed to callback |
| void SkSurface::asyncRescaleAndReadPixelsYUV420 | ( | SkYUVColorSpace | yuvColorSpace, |
| sk_sp< SkColorSpace > | dstColorSpace, | ||
| const SkIRect & | srcRect, | ||
| const SkISize & | dstSize, | ||
| RescaleGamma | rescaleGamma, | ||
| RescaleMode | rescaleMode, | ||
| ReadPixelsCallback | callback, | ||
| ReadPixelsContext | context | ||
| ) |
Similar to asyncRescaleAndReadPixels but performs an additional conversion to YUV.
The RGB->YUV conversion is controlled by 'yuvColorSpace'. The YUV data is returned as three planes ordered y, u, v. The u and v planes are half the width and height of the resized rectangle. The y, u, and v values are single bytes. Currently this fails if 'dstSize' width and height are not even. A 'srcRect' that is not contained by the bounds of the surface causes failure.
When the pixel data is ready the caller's ReadPixelsCallback is called with a AsyncReadResult containing the planar data. The AsyncReadResult will have count() == 3. Upon failure the callback is called with nullptr for AsyncReadResult. For a GPU surface this flushes work but a submit must occur to guarantee a finite time before the callback is called.
The data is valid for the lifetime of AsyncReadResult with the exception that if the SkSurface is GPU-backed the data is immediately invalidated if the context is abandoned or destroyed.
| yuvColorSpace | The transformation from RGB to YUV. Applied to the resized image after it is converted to dstColorSpace. |
| dstColorSpace | The color space to convert the resized image to, after rescaling. |
| srcRect | The portion of the surface to rescale and convert to YUV planes. |
| dstSize | The size to rescale srcRect to |
| rescaleGamma | controls whether rescaling is done in the surface's gamma or whether the source data is transformed to a linear gamma before rescaling. |
| rescaleMode | controls the sampling technique of the rescaling |
| callback | function to call with the planar read result |
| context | passed to callback |
| bool SkSurface::characterize | ( | SkSurfaceCharacterization * | characterization | ) | const |
Initializes SkSurfaceCharacterization that can be used to perform GPU back-end processing in a separate thread.
Typically this is used to divide drawing into multiple tiles. SkDeferredDisplayListRecorder records the drawing commands for each tile.
Return true if SkSurface supports characterization. raster surface returns false.
| characterization | properties for parallel drawing |
|
inlineprotected |
| bool SkSurface::draw | ( | sk_sp< const SkDeferredDisplayList > | deferredDisplayList, |
| int | xOffset = 0, |
||
| int | yOffset = 0 |
||
| ) |
Draws the deferred display list created via a SkDeferredDisplayListRecorder.
If the deferred display list is not compatible with this SkSurface, the draw is skipped and false is return.
The xOffset and yOffset parameters are experimental and, if not both zero, will cause the draw to be ignored. When implemented, if xOffset or yOffset are non-zero, the DDL will be drawn offset by that amount into the surface.
| deferredDisplayList | drawing commands |
| xOffset | x-offset at which to draw the DDL |
| yOffset | y-offset at which to draw the DDL |
| void SkSurface::draw | ( | SkCanvas * | canvas, |
| SkScalar | x, | ||
| SkScalar | y, | ||
| const SkSamplingOptions & | sampling, | ||
| const SkPaint * | paint | ||
| ) |
Draws SkSurface contents to canvas, with its top-left corner at (x, y).
If SkPaint paint is not nullptr, apply SkColorFilter, alpha, SkImageFilter, and SkBlendMode.
| canvas | SkCanvas drawn into |
| x | horizontal offset in SkCanvas |
| y | vertical offset in SkCanvas |
| sampling | what technique to use when sampling the surface pixels |
| paint | SkPaint containing SkBlendMode, SkColorFilter, SkImageFilter, and so on; or nullptr |
|
inline |
| GrSemaphoresSubmitted SkSurface::flush | ( | BackendSurfaceAccess | access, |
| const GrFlushInfo & | info | ||
| ) |
Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA.
A call to GrDirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but glFlush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.
Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command buffer or encoder objects. However, these objects are not sent to the gpu until a submission occurs.
The work that is submitted to the GPU will be dependent on the BackendSurfaceAccess that is passed in.
If BackendSurfaceAccess::kNoAccess is passed in all commands will be issued to the GPU.
If BackendSurfaceAccess::kPresent is passed in and the backend API is not Vulkan, it is treated the same as kNoAccess. If the backend API is Vulkan, the VkImage that backs the SkSurface will be transferred back to its original queue. If the SkSurface was created by wrapping a VkImage, the queue will be set to the queue which was originally passed in on the GrVkImageInfo. Additionally, if the original queue was not external or foreign the layout of the VkImage will be set to VK_IMAGE_LAYOUT_PRESENT_SRC_KHR.
The GrFlushInfo describes additional options to flush. Please see documentation at GrFlushInfo for more info.
If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, but must keep them alive until then. If a submit flag was passed in with the flush these valid semaphores can we waited on immediately. If this call returns GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardleess of semaphore submission the context will still be flushed. It should be emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.
Pending surface commands are flushed regardless of the return result.
| access | type of access the call will do on the backend object after flush |
| info | flush options |
| GrSemaphoresSubmitted SkSurface::flush | ( | const GrFlushInfo & | info, |
| const GrBackendSurfaceMutableState * | newState = nullptr |
||
| ) |
Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface MSAA.
A call to GrDirectContext::submit is always required to ensure work is actually sent to the gpu. Some specific API details: GL: Commands are actually sent to the driver, but glFlush is never called. Thus some sync objects from the flush will not be valid until a submission occurs.
Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command buffer or encoder objects. However, these objects are not sent to the gpu until a submission occurs.
The GrFlushInfo describes additional options to flush. Please see documentation at GrFlushInfo for more info.
If a GrBackendSurfaceMutableState is passed in, at the end of the flush we will transition the surface to be in the state requested by the GrBackendSurfaceMutableState. If the surface (or SkImage or GrBackendSurface wrapping the same backend object) is used again after this flush the state may be changed and no longer match what is requested here. This is often used if the surface will be used for presenting or external use and the client wants backend object to be prepped for that use. A finishedProc or semaphore on the GrFlushInfo will also include the work for any requested state change.
If the backend API is Vulkan, the caller can set the GrBackendSurfaceMutableState's VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to tell Skia to not change those respective states.
If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be submitted to the gpu during the next submit call (it is possible Skia failed to create a subset of the semaphores). The client should not wait on these semaphores until after submit has been called, but must keep them alive until then. If a submit flag was passed in with the flush these valid semaphores can we waited on immediately. If this call returns GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the client is still responsible for deleting any initialized semaphores. Regardleess of semaphore submission the context will still be flushed. It should be emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not happen. It simply means there were no semaphores submitted to the GPU. A caller should only take this as a failure if they passed in semaphores to be submitted.
Pending surface commands are flushed regardless of the return result.
| info | flush options |
| access | optional state change request after flush |
| void SkSurface::flushAndSubmit | ( | bool | syncCpu = false | ) |
Call to ensure all reads/writes of the surface have been issued to the underlying 3D API.
Skia will correctly order its own draws and pixel operations. This must to be used to ensure correct ordering when the surface backing store is accessed outside Skia (e.g. direct use of the 3D API or a windowing system). GrDirectContext has additional flush and submit methods that apply to all surfaces and images created from a GrDirectContext. This is equivalent to calling SkSurface::flush with a default GrFlushInfo followed by GrDirectContext::submit(syncCpu).
| uint32_t SkSurface::generationID | ( | ) |
Returns unique value identifying the content of SkSurface.
Returned value changes each time the content changes. Content is changed by drawing, or by calling notifyContentWillChange().
example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange
| GrBackendRenderTarget SkSurface::getBackendRenderTarget | ( | BackendHandleAccess | backendHandleAccess | ) |
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.
| GrBackendTexture SkSurface::getBackendTexture | ( | BackendHandleAccess | backendHandleAccess | ) |
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.
| SkCanvas* SkSurface::getCanvas | ( | ) |
|
inline |
Returns pixel row count; may be zero or greater.
| SkImageInfo SkSurface::imageInfo | ( | ) |
Returns an ImageInfo describing the surface.
| bool SkSurface::isCompatible | ( | const SkSurfaceCharacterization & | characterization | ) | const |
Is this surface compatible with the provided characterization?
This method can be used to determine if an existing SkSurface is a viable destination for an SkDeferredDisplayList.
| characterization | The characterization for which a compatibility check is desired |
|
static |
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.
If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
| 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 |
|
static |
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.
If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
| 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 SkImage capturing SkSurface contents.
Subsequent drawing to SkSurface contents are not captured. SkImage allocation is accounted for if SkSurface was created with SkBudgeted::kYes.
example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot
Like the no-parameter version, this returns an image of the current surface contents.
This variant takes a rectangle specifying the subset of the surface that is of interest. These bounds will be sanitized before being used.
example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot_2
|
inlinestatic |
Allocates raster SkSurface.
SkCanvas returned by SkSurface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is imageInfo.height() times imageInfo.minRowBytes(). Pixel memory is deleted 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.
| imageInfo | width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width and height must be greater than zero |
| props | LCD striping orientation and setting for device independent fonts; may be nullptr |
|
static |
Allocates raster SkSurface.
SkCanvas returned by SkSurface 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 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; rowBytes is large enough to contain info width pixels of SkColorType, or is zero.
If rowBytes is zero, a suitable value will be chosen internally.
| 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; may be zero |
| surfaceProps | LCD striping orientation and setting for device independent fonts; may be nullptr |
|
static |
Allocates raster SkSurface.
SkCanvas returned by SkSurface draws directly into 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().
| 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 |
|
inlinestatic |
|
static |
Allocates raster SkSurface.
SkCanvas returned by SkSurface draws directly into 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().
| 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 |
|
static |
Allocates raster SkSurface.
SkCanvas returned by SkSurface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is height times width times four. Pixel memory is deleted when SkSurface is deleted.
Internally, sets SkImageInfo to width, height, native color type, and kPremul_SkAlphaType.
SkSurface is returned if width and height are greater than zero.
Use to create SkSurface that matches SkPMColor, the native pixel arrangement on the platform. SkSurface drawn to output device skips converting its pixel format.
| 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 |
|
static |
Returns SkSurface on GPU indicated by context that is compatible with the provided characterization.
budgeted selects whether allocation for pixels is tracked by context.
| context | GPU context |
| characterization | description of the desired SkSurface |
|
inlinestatic |
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.
SkSurface bottom-left corner is pinned to the origin.
| context | GPU context |
| imageInfo | width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width, or height, or both, may be zero |
|
inlinestatic |
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.
SkSurface bottom-left corner is pinned to the origin.
| context | GPU context |
| imageInfo | width, height, SkColorType, SkAlphaType, SkColorSpace, of raster surface; width, or height, or both, may be zero |
| sampleCount | samples per pixel, or 0 to disable multi-sample anti-aliasing |
| surfaceProps | LCD striping orientation and setting for device independent fonts; may be nullptr |
|
static |
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.
If SK_SUPPORT_GPU is defined as zero, has no effect and returns nullptr.
| 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 |
| surfaceProps | LCD striping orientation and setting for device independent fonts; may be nullptr |
| shouldCreateWithMips | hint that SkSurface will host mip map images |
| sk_sp<SkSurface> SkSurface::makeSurface | ( | const SkImageInfo & | imageInfo | ) |
Returns a compatible SkSurface, or nullptr.
Returned SkSurface contains the same raster, GPU, or null properties as the original. Returned SkSurface does not share the same pixels.
Returns nullptr if imageInfo width or height are zero, or if imageInfo is incompatible with SkSurface.
| imageInfo | width, height, SkColorType, SkAlphaType, SkColorSpace, of SkSurface; width and height must be greater than zero |
Calls makeSurface(ImageInfo) with the same ImageInfo as this surface, but with the specified width and height.
| void SkSurface::notifyContentWillChange | ( | ContentChangeMode | mode | ) |
Notifies that SkSurface contents will be changed by code outside of Skia.
Subsequent calls to generationID() return a different value.
TODO: Can kRetain_ContentChangeMode be deprecated?
example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange
| bool SkSurface::peekPixels | ( | SkPixmap * | pixmap | ) |
Copies SkSurface pixel address, row bytes, and SkImageInfo to SkPixmap, if address is available, and returns true.
If pixel address is not available, return false and leave SkPixmap unchanged.
pixmap contents become invalid on any future change to SkSurface.
| pixmap | storage for pixel state if pixels are readable; otherwise, ignored |
|
inline |
Returns SkSurfaceProps for surface.
| bool SkSurface::readPixels | ( | const SkBitmap & | dst, |
| int | srcX, | ||
| int | srcY | ||
| ) |
Copies SkRect of pixels from SkSurface into bitmap.
Source SkRect corners are (srcX, srcY) and SkSurface (width(), height()). Destination SkRect 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 SkSurface is raster, or backed by a GPU.
The destination pixel storage must be allocated by the caller.
Pixel values are converted only if SkColorType and SkAlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside SkRect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down destination.
Does not copy, and returns false if:
| dst | storage for pixels copied from SkSurface |
| srcX | offset into readable pixels on x-axis; may be negative |
| srcY | offset into readable pixels on y-axis; may be negative |
| bool SkSurface::readPixels | ( | const SkImageInfo & | dstInfo, |
| void * | dstPixels, | ||
| size_t | dstRowBytes, | ||
| int | srcX, | ||
| int | srcY | ||
| ) |
Copies SkRect of pixels from SkCanvas into dstPixels.
Source SkRect corners are (srcX, srcY) and SkSurface (width(), height()). Destination SkRect 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 SkSurface is raster, or backed by a GPU.
The destination pixel storage must be allocated by the caller.
Pixel values are converted only if SkColorType and SkAlphaType do not match. Only pixels within both source and destination rectangles are copied. dstPixels contents outside SkRect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down destination.
Does not copy, and returns false if:
| dstInfo | width, height, SkColorType, and SkAlphaType 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 on x-axis; may be negative |
| srcY | offset into readable pixels on y-axis; may be negative |
| bool SkSurface::readPixels | ( | const SkPixmap & | dst, |
| int | srcX, | ||
| int | srcY | ||
| ) |
Copies SkRect of pixels to dst.
Source SkRect corners are (srcX, srcY) and SkSurface (width(), height()). Destination SkRect 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 SkSurface is raster, or backed by a GPU.
The destination pixel storage must be allocated by the caller.
Pixel values are converted only if SkColorType and SkAlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside SkRect intersection are unchanged.
Pass negative values for srcX or srcY to offset pixels across or down destination.
Does not copy, and returns false if:
| dst | storage for pixels copied from SkSurface |
| srcX | offset into readable pixels on x-axis; may be negative |
| srcY | offset into readable pixels on y-axis; may be negative |
| GrRecordingContext* SkSurface::recordingContext | ( | ) |
Returns the recording context being used by the SkSurface.
|
inlineinherited |
Increment the reference count.
Must be balanced by a call to unref().
| bool SkSurface::replaceBackendTexture | ( | const GrBackendTexture & | backendTexture, |
| GrSurfaceOrigin | origin, | ||
| ContentChangeMode | mode = kRetain_ContentChangeMode, |
||
| TextureReleaseProc | textureReleaseProc = nullptr, |
||
| ReleaseContext | releaseContext = nullptr |
||
| ) |
If the surface was made via MakeFromBackendTexture then it's backing texture may be substituted with a different texture.
The contents of the previous backing texture are copied into the new texture. SkCanvas state is preserved. The original sample count is used. The GrBackendFormat and dimensions of replacement texture must match that of the original.
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.
| backendTexture | the new backing texture for the surface |
| mode | Retain or discard current Content |
| textureReleaseProc | function called when texture can be released |
| releaseContext | state passed to textureReleaseProc |
|
inlineinherited |
May return true if the caller is the only owner.
Ensures that all previous owner's actions are complete.
|
inlineinherited |
Decrement the reference count.
If the reference count is 1 before the decrement, then delete the object. Note that if this is the case, then the object needs to have been allocated via new, and not on the stack.
| bool SkSurface::wait | ( | int | numSemaphores, |
| const GrBackendSemaphore * | waitSemaphores, | ||
| bool | deleteSemaphoresAfterWait = true |
||
| ) |
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.
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, regardless of the value of deleteSemaphoresAfterWait.
If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case it is the client's responsibility to not destroy or attempt to reuse the semaphores until it knows that Skia has finished waiting on them. This can be done by using finishedProcs on flush calls.
| numSemaphores | size of waitSemaphores array |
| waitSemaphores | array of semaphore containers @paramm deleteSemaphoresAfterWait who owns and should delete the semaphores |
|
inline |
Returns pixel count in each row; may be zero or greater.
| void SkSurface::writePixels | ( | const SkBitmap & | src, |
| int | dstX, | ||
| int | dstY | ||
| ) |
Copies SkRect of pixels from the src SkBitmap to the SkSurface.
Source SkRect corners are (0, 0) and (src.width(), src.height()). Destination SkRect corners are (dstX, dstY) and (dstX + Surface width(), dstY + Surface height()).
Copies each readable pixel intersecting both rectangles, without scaling, converting to SkSurface colorType() and SkSurface alphaType() if required.
| void SkSurface::writePixels | ( | const SkPixmap & | src, |
| int | dstX, | ||
| int | dstY | ||
| ) |
Copies SkRect of pixels from the src SkPixmap to the SkSurface.
Source SkRect corners are (0, 0) and (src.width(), src.height()). Destination SkRect corners are (dstX, dstY) and (dstX + Surface width(), dstY + Surface height()).
Copies each readable pixel intersecting both rectangles, without scaling, converting to SkSurface colorType() and SkSurface alphaType() if required.
|
static |
Deprecated.
|
static |
Deprecated.
|
static |
Deprecated.