Struct skia_bindings::SkImage

#[repr(C)]
pub struct SkImage {
    pub _base: SkRefCnt,
    pub fInfo: SkImageInfo,
    pub fUniqueID: u32,
}

Fields

_base: SkRefCnt

fInfo: SkImageInfo

fUniqueID: u32

Methods

impl SkImage

pub unsafe fn MakeRasterCopy(pixmap: *const SkPixmap) -> sk_sp<SkImage>

pub unsafe fn MakeRasterData(
    info: *const SkImageInfo,
    pixels: sk_sp<SkData>,
    rowBytes: usize
) -> sk_sp<SkImage>

pub unsafe fn MakeFromRaster(
    pixmap: *const SkPixmap,
    rasterReleaseProc: SkImage_RasterReleaseProc,
    releaseContext: SkImage_ReleaseContext
) -> sk_sp<SkImage>

pub unsafe fn MakeFromBitmap(bitmap: *const SkBitmap) -> sk_sp<SkImage>

pub unsafe fn MakeFromGenerator(
    imageGenerator: std_unique_ptr,
    subset: *const SkIRect
) -> sk_sp<SkImage>

pub unsafe fn MakeFromEncoded(
    encoded: sk_sp<SkData>,
    subset: *const SkIRect
) -> sk_sp<SkImage>

pub unsafe fn MakeFromCompressed(
    context: *mut GrContext,
    data: sk_sp<SkData>,
    width: c_int,
    height: c_int,
    type_: SkImage_CompressionType
) -> sk_sp<SkImage>

pub unsafe fn MakeFromTexture(
    context: *mut GrContext,
    backendTexture: *const GrBackendTexture,
    origin: GrSurfaceOrigin,
    colorType: SkColorType,
    alphaType: SkAlphaType,
    colorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromTexture1(
    context: *mut GrContext,
    backendTexture: *const GrBackendTexture,
    origin: GrSurfaceOrigin,
    colorType: SkColorType,
    alphaType: SkAlphaType,
    colorSpace: sk_sp<SkColorSpace>,
    textureReleaseProc: SkImage_TextureReleaseProc,
    releaseContext: SkImage_ReleaseContext
) -> sk_sp<SkImage>

pub unsafe fn MakeCrossContextFromEncoded(
    context: *mut GrContext,
    data: sk_sp<SkData>,
    buildMips: bool,
    dstColorSpace: *mut SkColorSpace,
    limitToMaxTextureSize: bool
) -> sk_sp<SkImage>

pub unsafe fn MakeCrossContextFromPixmap(
    context: *mut GrContext,
    pixmap: *const SkPixmap,
    buildMips: bool,
    dstColorSpace: *mut SkColorSpace,
    limitToMaxTextureSize: bool
) -> sk_sp<SkImage>

pub unsafe fn MakeFromAdoptedTexture(
    context: *mut GrContext,
    backendTexture: *const GrBackendTexture,
    surfaceOrigin: GrSurfaceOrigin,
    colorType: SkColorType,
    alphaType: SkAlphaType,
    colorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVATexturesCopy(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvaTextures: *const GrBackendTexture,
    yuvaIndices: *const SkYUVAIndex,
    imageSize: SkISize,
    imageOrigin: GrSurfaceOrigin,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVATexturesCopyWithExternalBackend(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvaTextures: *const GrBackendTexture,
    yuvaIndices: *const SkYUVAIndex,
    imageSize: SkISize,
    imageOrigin: GrSurfaceOrigin,
    backendTexture: *const GrBackendTexture,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVATextures(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvaTextures: *const GrBackendTexture,
    yuvaIndices: *const SkYUVAIndex,
    imageSize: SkISize,
    imageOrigin: GrSurfaceOrigin,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVAPixmaps(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvaPixmaps: *const SkPixmap,
    yuvaIndices: *const SkYUVAIndex,
    imageSize: SkISize,
    imageOrigin: GrSurfaceOrigin,
    buildMips: bool,
    limitToMaxTextureSize: bool,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVTexturesCopy(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvTextures: *const GrBackendTexture,
    imageOrigin: GrSurfaceOrigin,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromYUVTexturesCopyWithExternalBackend(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    yuvTextures: *const GrBackendTexture,
    imageOrigin: GrSurfaceOrigin,
    backendTexture: *const GrBackendTexture,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromNV12TexturesCopy(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    nv12Textures: *const GrBackendTexture,
    imageOrigin: GrSurfaceOrigin,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromNV12TexturesCopyWithExternalBackend(
    context: *mut GrContext,
    yuvColorSpace: SkYUVColorSpace,
    nv12Textures: *const GrBackendTexture,
    imageOrigin: GrSurfaceOrigin,
    backendTexture: *const GrBackendTexture,
    imageColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn MakeFromPicture(
    picture: sk_sp<SkPicture>,
    dimensions: *const SkISize,
    matrix: *const SkMatrix,
    paint: *const SkPaint,
    bitDepth: SkImage_BitDepth,
    colorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn imageInfo(&self) -> *const SkImageInfo

pub unsafe fn width(&self) -> c_int

pub unsafe fn height(&self) -> c_int

pub unsafe fn dimensions(&self) -> SkISize

pub unsafe fn bounds(&self) -> SkIRect

pub unsafe fn uniqueID(&self) -> u32

pub unsafe fn alphaType(&self) -> SkAlphaType

pub unsafe fn colorType(&self) -> SkColorType

pub unsafe fn colorSpace(&self) -> *mut SkColorSpace

pub unsafe fn refColorSpace(&self) -> sk_sp<SkColorSpace>

pub unsafe fn isAlphaOnly(&self) -> bool

pub unsafe fn isOpaque(&self) -> bool

pub unsafe fn makeShader(
    &self,
    tmx: SkTileMode,
    tmy: SkTileMode,
    localMatrix: *const SkMatrix
) -> sk_sp<SkShader>

pub unsafe fn makeShader1(
    &self,
    localMatrix: *const SkMatrix
) -> sk_sp<SkShader>

pub unsafe fn peekPixels(&self, pixmap: *mut SkPixmap) -> bool

pub unsafe fn getTexture(&self) -> *mut GrTexture

pub unsafe fn isTextureBacked(&self) -> bool

pub unsafe fn isValid(&self, context: *mut GrContext) -> bool

pub unsafe fn flush(
    &mut self,
    context: *mut GrContext,
    flushInfo: *const GrFlushInfo
) -> GrSemaphoresSubmitted

pub unsafe fn flush1(&mut self, arg1: *mut GrContext)

pub unsafe fn getBackendTexture(
    &self,
    flushPendingGrContextIO: bool,
    origin: *mut GrSurfaceOrigin
) -> GrBackendTexture

pub unsafe fn readPixels(
    &self,
    dstInfo: *const SkImageInfo,
    dstPixels: *mut c_void,
    dstRowBytes: usize,
    srcX: c_int,
    srcY: c_int,
    cachingHint: SkImage_CachingHint
) -> bool

pub unsafe fn readPixels1(
    &self,
    dst: *const SkPixmap,
    srcX: c_int,
    srcY: c_int,
    cachingHint: SkImage_CachingHint
) -> bool

pub unsafe fn scalePixels(
    &self,
    dst: *const SkPixmap,
    filterQuality: SkFilterQuality,
    cachingHint: SkImage_CachingHint
) -> bool

pub unsafe fn encodeToData(
    &self,
    encodedImageFormat: SkEncodedImageFormat,
    quality: c_int
) -> sk_sp<SkData>

pub unsafe fn encodeToData1(&self) -> sk_sp<SkData>

pub unsafe fn refEncodedData(&self) -> sk_sp<SkData>

pub unsafe fn makeSubset(&self, subset: *const SkIRect) -> sk_sp<SkImage>

pub unsafe fn makeTextureImage(
    &self,
    context: *mut GrContext,
    dstColorSpace: *mut SkColorSpace,
    mipMapped: GrMipMapped
) -> sk_sp<SkImage>

pub unsafe fn makeNonTextureImage(&self) -> sk_sp<SkImage>

pub unsafe fn makeRasterImage(&self) -> sk_sp<SkImage>

pub unsafe fn makeWithFilter(
    &self,
    context: *mut GrContext,
    filter: *const SkImageFilter,
    subset: *const SkIRect,
    clipBounds: *const SkIRect,
    outSubset: *mut SkIRect,
    offset: *mut SkIPoint
) -> sk_sp<SkImage>

pub unsafe fn makeWithFilter1(
    &self,
    filter: *const SkImageFilter,
    subset: *const SkIRect,
    clipBounds: *const SkIRect,
    outSubset: *mut SkIRect,
    offset: *mut SkIPoint
) -> sk_sp<SkImage>

pub unsafe fn MakeBackendTextureFromSkImage(
    context: *mut GrContext,
    image: sk_sp<SkImage>,
    backendTexture: *mut GrBackendTexture,
    backendTextureReleaseProc: *mut SkImage_BackendTextureReleaseProc
) -> bool

pub unsafe fn asLegacyBitmap(
    &self,
    bitmap: *mut SkBitmap,
    legacyBitmapMode: SkImage_LegacyBitmapMode
) -> bool

pub unsafe fn isLazyGenerated(&self) -> bool

pub unsafe fn makeColorSpace(
    &self,
    target: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

pub unsafe fn makeColorTypeAndColorSpace(
    &self,
    targetColorType: SkColorType,
    targetColorSpace: sk_sp<SkColorSpace>
) -> sk_sp<SkImage>

Trait Implementations

impl Debug for SkImage

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.