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); }