SkSpecialImages Namespace Reference

Functions
sk_sp< SkSpecialImage >	MakeFromRaster (const SkIRect &subset, const SkBitmap &bm, const SkSurfaceProps &props)
sk_sp< SkSpecialImage >	CopyFromRaster (const SkIRect &subset, const SkBitmap &bm, const SkSurfaceProps &props)
sk_sp< SkSpecialImage >	MakeFromRaster (const SkIRect &subset, sk_sp< SkImage > image, const SkSurfaceProps &props)
bool	AsBitmap (const SkSpecialImage *img, SkBitmap *result)
sk_sp< SkSpecialImage >	MakeFromTextureImage (GrRecordingContext *rContext, const SkIRect &subset, sk_sp< SkImage > image, const SkSurfaceProps &props)
sk_sp< SkSpecialImage >	MakeDeferredFromGpu (GrRecordingContext *context, const SkIRect &subset, uint32_t uniqueID, GrSurfaceProxyView view, const GrColorInfo &colorInfo, const SkSurfaceProps &props)
GrSurfaceProxyView	AsView (GrRecordingContext *context, const SkSpecialImage *img)
GrSurfaceProxyView	AsView (GrRecordingContext *rContext, const sk_sp< const SkSpecialImage > &img)
sk_sp< SkSpecialImage >	MakeGraphite (skgpu::graphite::Recorder *recorder, const SkIRect &subset, sk_sp< SkImage > image, const SkSurfaceProps &props)

Function Documentation

AsBitmap()

bool SkSpecialImages::AsBitmap	(	const SkSpecialImage *	img,
		SkBitmap *	result
	)

Definition at line 198 of file SkSpecialImage.cpp.

                                                           {
    if (!img || img->isGaneshBacked() || img->isGraphiteBacked()) {
        return false;
    }
    auto rasterImg = static_cast<const SkSpecialImage_Raster*>(img);
    return rasterImg->getROPixels(result);
}

AsView() [1/2]

GrSurfaceProxyView SkSpecialImages::AsView	(	GrRecordingContext *	,
		const SkSpecialImage *
	)

Regardless of how the underlying backing data is stored, returns the contents as a GrSurfaceProxyView. The returned view's proxy represents the entire backing image, so texture coordinates must be mapped from the content rect (e.g. relative to 'subset()') to the proxy's space (offset by subset().topLeft()).

Definition at line 115 of file SkSpecialImage_Ganesh.cpp.

                                                                                  {
    if (!context || !img || !img->isGaneshBacked()) {
        return {};
    }
    auto grImg = static_cast<const SkSpecialImage_Gpu*>(img);
    return grImg->view(context);
}

AsView() [2/2]

GrSurfaceProxyView SkSpecialImages::AsView ( GrRecordingContext *  rContext, const sk_sp< const SkSpecialImage > &  img  )

inline

Definition at line 44 of file SkSpecialImage_Ganesh.h.

                                                                         {
    return AsView(rContext, img.get());
}

CopyFromRaster()

sk_sp< SkSpecialImage > SkSpecialImages::CopyFromRaster	(	const SkIRect &	subset,
		const SkBitmap &	bm,
		const SkSurfaceProps &	props
	)

Definition at line 151 of file SkSpecialImage.cpp.

                                                                  {
    SkASSERT(bm.bounds().contains(subset));
 
    if (!bm.pixelRef()) {
        return nullptr;
    }
 
    SkBitmap tmp;
    SkImageInfo info = bm.info().makeDimensions(subset.size());
    // As in MakeFromRaster, must force src to N32 for ImageFilters
    if (!valid_for_imagefilters(bm.info())) {
        info = info.makeColorType(kN32_SkColorType);
    }
    if (!tmp.tryAllocPixels(info)) {
        return nullptr;
    }
    if (!bm.readPixels(tmp.info(), tmp.getPixels(), tmp.rowBytes(), subset.x(), subset.y())) {
        return nullptr;
    }
 
    // Since we're making a copy of the raster, the resulting special image is the exact size
    // of the requested subset of the original and no longer needs to be offset by subset's left
    // and top, since those were relative to the original's buffer.
    return sk_make_sp<SkSpecialImage_Raster>(
            SkIRect::MakeWH(subset.width(), subset.height()), tmp, props);
}

MakeDeferredFromGpu()

sk_sp< SkSpecialImage > SkSpecialImages::MakeDeferredFromGpu	(	GrRecordingContext *	context,
		const SkIRect &	subset,
		uint32_t	uniqueID,
		GrSurfaceProxyView	view,
		const GrColorInfo &	colorInfo,
		const SkSurfaceProps &	props
	)

Definition at line 93 of file SkSpecialImage_Ganesh.cpp.

                                                                       {
    if (!context || context->abandoned() || !view.asTextureProxy()) {
        return nullptr;
    }
 
    SkASSERT(view.proxy()->backingStoreBoundsIRect().contains(subset));
 
    SkColorType ct = GrColorTypeToSkColorType(colorInfo.colorType());
    return sk_make_sp<SkSpecialImage_Gpu>(
            context,
            subset,
            uniqueID,
            std::move(view),
            SkColorInfo(ct, colorInfo.alphaType(), colorInfo.refColorSpace()),
            props);
}

MakeFromRaster() [1/2]

sk_sp< SkSpecialImage > SkSpecialImages::MakeFromRaster	(	const SkIRect &	subset,
		const SkBitmap &	bm,
		const SkSurfaceProps &	props
	)

Definition at line 128 of file SkSpecialImage.cpp.

                                                                  {
    SkASSERT(bm.bounds().contains(subset));
 
    if (!bm.pixelRef()) {
        return nullptr;
    }
 
    const SkBitmap* srcBM = &bm;
    SkBitmap tmp;
    // ImageFilters only handle N32 at the moment, so force our src to be that
    if (!valid_for_imagefilters(bm.info())) {
        if (!tmp.tryAllocPixels(bm.info().makeColorType(kN32_SkColorType)) ||
            !bm.readPixels(tmp.info(), tmp.getPixels(), tmp.rowBytes(), 0, 0))
        {
            return nullptr;
        }
        srcBM = &tmp;
    }
    return sk_make_sp<SkSpecialImage_Raster>(subset, *srcBM, props);
}

MakeFromRaster() [2/2]

sk_sp< SkSpecialImage > SkSpecialImages::MakeFromRaster	(	const SkIRect &	subset,
		sk_sp< SkImage >	image,
		const SkSurfaceProps &	props
	)

Definition at line 180 of file SkSpecialImage.cpp.

                                                                  {
    if (!image || subset.isEmpty()) {
        return nullptr;
    }
 
    SkASSERT(image->bounds().contains(subset));
    SkASSERT(!image->isTextureBacked());
 
    // This will not work if the image is uploaded to a GPU render target.
    SkBitmap bm;
    if (as_IB(image)->getROPixels(nullptr, &bm)) {
        return MakeFromRaster(subset, bm, props);
    }
    return nullptr;
}

MakeFromTextureImage()

sk_sp< SkSpecialImage > SkSpecialImages::MakeFromTextureImage	(	GrRecordingContext *	rContext,
		const SkIRect &	subset,
		sk_sp< SkImage >	image,
		const SkSurfaceProps &	props
	)

Definition at line 73 of file SkSpecialImage_Ganesh.cpp.

                                                                        {
    if (!rContext || !image || subset.isEmpty()) {
        return nullptr;
    }
 
    SkASSERT(image->bounds().contains(subset));
 
    // This will work even if the image is a raster-backed image.
    auto [view, ct] = skgpu::ganesh::AsView(rContext, image, skgpu::Mipmapped::kNo);
    return MakeDeferredFromGpu(rContext,
                               subset,
                               image->uniqueID(),
                               std::move(view),
                               {ct, image->alphaType(), image->refColorSpace()},
                               props);
}

MakeGraphite()

sk_sp< SkSpecialImage > SkSpecialImages::MakeGraphite	(	skgpu::graphite::Recorder *	recorder,
		const SkIRect &	subset,
		sk_sp< SkImage >	image,
		const SkSurfaceProps &	props
	)

Definition at line 56 of file SpecialImage_Graphite.cpp.

                                                                {
    // 'recorder' can be null if we're wrapping a graphite-backed image since there's no work that
    // needs to be added. This can happen when snapping a special image from a Device that's been
    // marked as immutable and abandoned its recorder.
    if (!image || subset.isEmpty()) {
        return nullptr;
    }
 
    SkASSERT(image->bounds().contains(subset));
 
    // Use the Recorder's client ImageProvider to convert to a graphite-backed image when
    // possible, but this does not necessarily mean the provider will produce a valid image.
    if (!as_IB(image)->isGraphiteBacked()) {
        if (!recorder) {
            return nullptr;
        }
        auto [graphiteImage, _] =
                skgpu::graphite::GetGraphiteBacked(recorder, image.get(), {});
        if (!graphiteImage) {
            return nullptr;
        }
 
        image = graphiteImage;
    }
 
    return sk_make_sp<skgpu::graphite::SpecialImage>(subset, std::move(image), props);
}