void SkAnimatedImage::onDraw(SkCanvas* canvas) {
auto image = SkMakeImageFromRasterBitmap(fDisplayFrame.fBitmap,
kNever_SkCopyPixelsMode);
if (fSimple) {
canvas->drawImage(image, 0, 0);
return;
}
SkRect bounds = this->getBounds();
if (fPostProcess) {
canvas->saveLayer(&bounds, nullptr);
}
{
SkAutoCanvasRestore acr(canvas, fPostProcess);
canvas->concat(fMatrix);
SkPaint paint;
paint.setFilterQuality(kLow_SkFilterQuality);
canvas->drawImage(image, 0, 0, &paint);
}
if (fPostProcess) {
canvas->drawPicture(fPostProcess);
canvas->restore();
}
}
sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) {
SkPixelRef* pr = bm.pixelRef();
if (nullptr == pr) {
return nullptr;
}
#if SK_SUPPORT_GPU
if (GrTexture* tex = pr->getTexture()) {
SkAutoTUnref<GrTexture> unrefCopy;
if (!bm.isImmutable()) {
tex = GrDeepCopyTexture(tex, SkBudgeted::kNo);
if (nullptr == tex) {
return nullptr;
}
unrefCopy.reset(tex);
}
const SkImageInfo info = bm.info();
return sk_make_sp<SkImage_Gpu>(info.width(), info.height(), bm.getGenerationID(),
info.alphaType(), tex, sk_ref_sp(info.colorSpace()),
SkBudgeted::kNo);
}
#endif
// This will check for immutable (share or copy)
return SkMakeImageFromRasterBitmap(bm);
}
sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
SkShader::TileMode tmy, const SkMatrix* localMatrix,
SkTBlitterAllocator* allocator) {
ForceCopyMode mode = allocator ? kNever_ForceCopyMode : kNo_ForceCopyMode;
return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, mode).get(),
tmx, tmy, localMatrix, allocator);
}
sk_sp<GrTextureProxy> GrUploadBitmapToTextureProxy(GrProxyProvider* proxyProvider,
const SkBitmap& bitmap,
SkColorSpace* dstColorSpace) {
if (!bitmap.peekPixels(nullptr)) {
return nullptr;
}
SkDestinationSurfaceColorMode colorMode = dstColorSpace
? SkDestinationSurfaceColorMode::kGammaAndColorSpaceAware
: SkDestinationSurfaceColorMode::kLegacy;
if (!SkImageInfoIsValid(bitmap.info(), colorMode)) {
return nullptr;
}
// In non-ddl we will always instantiate right away. Thus we never want to copy the SkBitmap
// even if it's mutable. In ddl, if the bitmap is mutable then we must make a copy since the
// upload of the data to the gpu can happen at anytime and the bitmap may change by then.
SkCopyPixelsMode cpyMode = proxyProvider->mutableBitmapsNeedCopy() ? kIfMutable_SkCopyPixelsMode
: kNever_SkCopyPixelsMode;
sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, cpyMode);
return proxyProvider->createTextureProxy(std::move(image), kNone_GrSurfaceFlags,
kTopLeft_GrSurfaceOrigin, 1, SkBudgeted::kYes,
SkBackingFit::kExact);
}
sk_sp<SkImage> SkImage::MakeFromBitmap(const SkBitmap& bm) {
SkPixelRef* pr = bm.pixelRef();
if (nullptr == pr) {
return nullptr;
}
return SkMakeImageFromRasterBitmap(bm, kIfMutable_SkCopyPixelsMode);
}
sk_sp<SkImage> SkColorSpaceXformer::apply(const SkBitmap& src) {
const AutoCachePurge autoPurge(this);
sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(src, kNever_SkCopyPixelsMode);
if (!image) {
return nullptr;
}
sk_sp<SkImage> xformed = image->makeColorSpace(fDst);
// We want to be sure we don't let the kNever_SkCopyPixelsMode image escape this stack frame.
SkASSERT(xformed != image);
return xformed;
}
sk_sp<SkImage> SkSurface_Raster::onNewImageSnapshot(SkBudgeted, SkCopyPixelsMode cpm) {
if (fWeOwnThePixels) {
// SkImage_raster requires these pixels are immutable for its full lifetime.
// We'll undo this via onRestoreBackingMutability() if we can avoid the COW.
if (SkPixelRef* pr = fBitmap.pixelRef()) {
pr->setTemporarilyImmutable();
}
} else {
cpm = kAlways_SkCopyPixelsMode;
}
// Our pixels are in memory, so read access on the snapshot SkImage could be cheap.
// Lock the shared pixel ref to ensure peekPixels() is usable.
return SkMakeImageFromRasterBitmap(fBitmap, cpm);
}
sk_sp<GrTextureProxy> GrMakeCachedBitmapProxy(GrProxyProvider* proxyProvider,
const SkBitmap& bitmap,
SkBackingFit fit) {
if (!bitmap.peekPixels(nullptr)) {
return nullptr;
}
// In non-ddl we will always instantiate right away. Thus we never want to copy the SkBitmap
// even if its mutable. In ddl, if the bitmap is mutable then we must make a copy since the
// upload of the data to the gpu can happen at anytime and the bitmap may change by then.
SkCopyPixelsMode cpyMode = proxyProvider->mutableBitmapsNeedCopy() ? kIfMutable_SkCopyPixelsMode
: kNever_SkCopyPixelsMode;
sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, cpyMode);
if (!image) {
return nullptr;
}
return GrMakeCachedImageProxy(proxyProvider, std::move(image), fit);
}
void SkOverdrawCanvas::onDrawBitmapLattice(const SkBitmap& bitmap, const Lattice& lattice,
const SkRect& dst, const SkPaint* paint) {
sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
this->onDrawImageLattice(image.get(), lattice, dst, paint);
}
sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx,
SkShader::TileMode tmy, const SkMatrix* localMatrix,
SkCopyPixelsMode cpm) {
return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm),
tmx, tmy, localMatrix);
}
