SkImage is an abstraction for drawing a rectangle of pixels, though the particular type of image could be actually storing its data on the GPU, or as drawing commands (picture or PDF or otherwise), ready to be played back into another canvas. The content of SkImage is always immutable, though the actual storage may change, if for example that image can be re-created via encoded data or other means. SkImage always has a non-zero dimensions. If there is a request to create a new image, either directly or via SkSurface, and either of the requested dimensions are zero, then nullptr will be returned.
| topics | description |
|---|
| description | struct |
|---|---|
| DeferredTextureImageUsageParams |
| description | function |
|---|---|
| MakeFromAHardwareBuffer | |
| MakeBackendTextureFromSkImage | |
| MakeCrossContextFromEncoded | |
| MakeFromAHardwareBuffer | |
| MakeFromAdoptedTexture | |
| MakeFromBitmap | |
| MakeFromDeferredTextureImageData | |
| MakeFromEncoded | |
| MakeFromGenerator | |
| MakeFromNV12TexturesCopy | |
| MakeFromPicture | |
| MakeFromRaster | |
| MakeFromTexture | |
| MakeFromYUVTexturesCopy | |
| MakeRasterCopy | |
| MakeRasterData | |
| alphaType | |
| asLegacyBitmap | |
| bounds | |
| colorSpace | |
| dimensions | |
| encodeToData | |
| getDeferredTextureImageData | |
| getTexture | |
| getTextureHandle | |
| height | |
| isAlphaOnly | |
| isLazyGenerated | |
| isOpaque | |
| isTextureBacked | |
| isValid | |
| makeColorSpace | |
| makeNonTextureImage | |
| makeShader | |
| makeSubset | |
| makeTextureImage | |
| makeWithFilter | |
| peekPixels | |
| readPixels | |
| refColorSpace | |
| refEncodedData | |
| scalePixels | |
| toString | |
| uniqueID | |
| width |
Drawing parameters for which a deferred texture image data should be optimized. */
incomplete
incomplete
SkMatrix fMatrix
SkFilterQuality fQuality
int fPreScaleMipLevel
incomplete
incomplete
incomplete
incomplete
Return a new Image referencing the specified pixels. These must remain valid and unchanged until the specified release-proc is called, indicating that Skia no longer has a reference to the pixels. Returns nullptr if the requested pixmap info is unsupported.
incomplete
incomplete
Construct a new image from the specified bitmap. If the bitmap is marked immutable, and its pixel memory is shareable, it may be shared instead of copied.
incomplete
incomplete
Construct a new SkImage based on the given ImageGenerator. Returns nullptr on error. This function will always take ownership of the passed generator. If a subset is specified, it must be contained within the generator's bounds.
incomplete
incomplete
Construct a new SkImage based on the specified encoded data. Returns nullptr on failure, which can mean that the format of the encoded data was not recognized/supported. If a subset is specified, it must be contained within the encoded data's bounds.
incomplete
incomplete
Create a new image from the specified descriptor. Note - the caller is responsible for managing the lifetime of the underlying platform texture. Will return nullptr if the specified back-end texture is unsupported.
incomplete
incomplete
Create a new image from the GrBackendTexture. The underlying platform texture must stay valid and unaltered until the specified release-proc is invoked, indicating that Skia no longer is holding a reference to it. Will return nullptr if the specified back-end texture is unsupported.
incomplete
incomplete
Decodes and uploads the encoded data to a GPU backed image using the supplied GrContext. That image can be safely used by other GrContexts, across thread boundaries. The GrContext used here, and the ones used to draw this image later must be in the same OpenGL share group, or otherwise be able to share resources. When the image's ref count reaches zero, the original GrContext will destroy the texture, asynchronously. The texture will be decoded and uploaded to be suitable for use with surfaces that have the supplied destination color space. The color space of the image itself will be determined from the encoded data.
incomplete
incomplete
Create a new image from the specified descriptor. Note - Skia will delete or recycle the texture when the image is released. Will return nullptr if the specified back-end texture is unsupported.
incomplete
incomplete
Create a new image by copying the pixels from the specified y, u, v textures. The data from the textures is immediately ingested into the image and the textures can be modified or deleted after the function returns. The image will have the dimensions of the y texture.
incomplete
incomplete
Create a new image by copying the pixels from the specified y and UV Mapping. The data from the textures is immediately ingested into the image and the textures can be modified or deleted after the function returns. The image will have the dimensions of the y texture.
incomplete
incomplete
incomplete
Create a new image from the specified picture. On creation of the SkImage, snap the SkPicture to a particular BitDepth and SkColorSpace.
incomplete
incomplete
Create a new image from the an Android hardware buffer. The new image takes a reference on the buffer.
Only available on Android, when __ANDROID API is defined to be 26 or greater.
incomplete
incomplete
Create a new image from the an Android hardware buffer. The new image takes a reference on the buffer.
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
Returns Color Space of Image. Color Space may have been a parameter when Image was created, or may have been parsed from encoded data. Skia may not be able to draw image respecting returned Color Space or draw into Surface with returned Color Space.
Color Space Image was created with, or nullptr
incomplete
incomplete
incomplete
Returns true fi the image will be drawn as a mask, with no intrinsic color of its own.
incomplete
incomplete
incomplete
incomplete
incomplete
incomplete
Helper version of
incomplete
incomplete
If the image has direct access to its pixels (i.e. they are in local RAM) return true, and if not null, return in the pixmap parameter the info about the images pixels. On failure, return false and ignore the pixmap parameter.
incomplete
incomplete
DEPRECATED -
incomplete
incomplete
Returns true if the image is texture backed.
incomplete
incomplete
Returns true if Image can be drawn. If context is nullptr, tests if Image draws on Raster Surface; Otherwise, tests if Image draws on GPU Surface associated with context.
Texture-backed images may become invalid if their underlying GrContext is abandoned. Some generator-backed images may be invalid for CPU and/or GPU.
incomplete
incomplete
Retrieves the back-end API handle of the texture. If flushPendingGrContextIO then the GrContext will issue to the back-end API any deferred I/O operations on the texture before returning. If 'origin' is supplied it will be filled in with the origin of the content drawn into the image.
incomplete
incomplete
Hints to image calls where the system might cache computed intermediates (e.g. the results of decoding or a read-back from the GPU. Passing kAllow CachingHint signals that the system's default behavior is fine. Passing kDisallow CachingHint signals that caching should be avoided.
incomplete
Copy the pixels from the image into the specified buffer (dstPixels + dstRowBytes), converting them into the requested format (dstInfo). The image pixels are read starting at the specified (srcX, srcY) location. dstInfo and (srcX, srcY) offset specifies a source rectangle:
The source rectangle is intersected with the bounds of the image. If this intersection is not empty, then we have two sets of pixels (of equal size). Replace dstPixels with the corresponding Image pixels, performing any Color Type/Alpha Type transformations needed (in the case where Image and dstInfo have different Color Types or Alpha Types). This call can fail, returning false, for several reasons: if source rectangle does not intersect the image bounds; if the requested Color Type/Alpha Type cannot be converted from the image's types.
incomplete
incomplete
incomplete
incomplete
Copies Image pixels into dst, converting to dst Color Type and Alpha Type. If the conversion cannot be performed, false is returned. If dst dimensions differ from Image dimensions, Image is scaled, applying filterQuality.
incomplete
incomplete
Encode the image's pixels and return the result as SkData. If the image type cannot be encoded, or the requested encoder format is not supported, this will return nullptr.
incomplete
incomplete
Encodes Image and returns result as SkData. Will reuse existing encoded data if present, as returned by refEncodedData. pixelSerializer validates existing encoded data, and encodes Image when existing encoded data is missing or invalid.
Passing nullptr for pixelSerializer selects default serialization which accepts all data and encodes to PNG.
Returns nullptr if existing encoded data is missing or invalid and encoding fails.
incomplete
incomplete
If the image already has its contents in encoded form (e.g. PNG or JPEG), return that as SkData. If the image does not already has its contents in encoded form, return nullptr.
To force the image to return its contents as encoded data, call encodeToData.
incomplete
incomplete
incomplete
incomplete
Return a new image that is a subset of this image. The underlying implementation may share the pixels, or it may make a copy. If subset does not intersect the bounds of this image, or the copy/share cannot be made, nullptr will be returned.
incomplete
incomplete
Ensures that an image is backed by a texture (when GrContext is non-null), suitable for use with surfaces that have the supplied destination color space. If no transformation is required, the returned image may be the same as this image. If this image is from a different GrContext, this will fail.
incomplete
incomplete
If the image is texture-backed this will make a raster copy of it (or nullptr if reading back the pixels fails). Otherwise, it returns the original image.
incomplete
incomplete
Apply a given image filter to this image, and return the filtered result. The subset represents the active portion of this image. The return value is similarly an SkImage, with an active subset (outSubset). This is usually used with texture-backed images, where the texture may be approx-match and thus larger than the required size. clipBounds constrains the device-space extent of the image, stored in outSubset. offset is storage, set to the amount to translate the result when drawn. If the result image cannot be created, or the result would be transparent black, null is returned, in which case the offset and outSubset parameters should be ignored by the caller.
incomplete
incomplete
This method allows clients to capture the data necessary to turn a SkImage into a texture- backed image. If the original image is codec-backed this will decode into a format optimized for the context represented by the proxy. This method is thread safe with respect to the GrContext whence the proxy came. Clients allocate and manage the storage of the deferred texture data and control its lifetime. No cleanup is required, thus it is safe to simply free the memory out from under the data.
The same method is used both for getting the size necessary for uploading and retrieving texture data. The deferredTextureImageUsageParams array represents the set of draws over which to optimize the texture data prior to uploading.
When called with a null buffer this returns the size that the client must allocate in order to create deferred texture data for this image (or zero if this is an inappropriate candidate). The buffer allocated by the client should be 8 byte aligned. When buffer is not null this fills in the deferred texture data for this image in the provided buffer (assuming this is an appropriate candidate image and the buffer is appropriately aligned). Upon success the size written is returned, otherwise 0. dstColorSpace is the color space of the surface where this texture will ultimately be used. If the method determines that Mip Maps are needed, this helps determine the correct strategy for building them (gamma-correct or not).
dstColorType is the color type of the surface where this texture will ultimately be used. This determines the format with which the image will be uploaded to the GPU. If dstColorType does not support color spaces (low bit depth types such as kARGB 4444 SkColorType), then dstColorSpace must be null.
incomplete
incomplete
Returns a texture-backed image from data produced in SkImage::getDeferredTextureImageData. The context must be the context that provided the proxy passed to getDeferredTextureImageData.
incomplete
incomplete
BackendTextureReleaseProc
Creates a GrBackendTexture from the provided SkImage. Returns true on success. The GrBackendTexture and BackendTextureReleaseProc are populated on success. It is the callers responsibility to call the BackendTextureReleaseProc once they have deleted the texture. Note that the BackendTextureReleaseProc allows Skia to clean up auxiliary data related to the GrBackendTexture, and is not a substitute for the client deleting the GrBackendTexture themselves.
If image is both texture backed and singly referenced; that is, its only reference was transferred using std::move(): image is returned in backendTexture without conversion or making a copy.
If the SkImage is not texture backed, this function will generate a texture with the image's contents and return that.
incomplete
incomplete
Helper functions to convert to SkBitmap
incomplete
Attempt to create a bitmap with the same pixels as the image. The result will always be a raster-backed bitmap (texture-backed bitmaps are DEPRECATED, and not supported here). If the mode is kRO LegacyBitmapMode (read-only), the resulting bitmap will be marked as immutable. On success, returns true. On failure, returns false and the bitmap parameter will be reset to empty.
incomplete
incomplete
Returns true if Image is backed by an image-generator or other service that creates and caches its pixels or texture on-demand.
incomplete
incomplete
If target is supported, returns an SkImage in target color space. Otherwise, returns nullptr. This will leave the image as is if it already in target color space. Otherwise, it will convert the pixels from Image color space to target color space. If this->colorSpace is nullptr, Image color space will be treated as sRGB.
If premulBehavior is SkTransferFunctionBehavior::kRespect: converts Image pixels to a linear space before converting to match destination Color Type and Color Space. If premulBehavior is SkTransferFunctionBehavior::kIgnore: Image pixels are treated as if they are linear, regardless of how they are encoded.
incomplete
incomplete