class SkPixelRefFactory;
class SkRegion;
class SkString;
+
+#ifdef SK_SUPPORT_LEGACY_BITMAP_GETTEXTURE
class GrTexture;
+#endif
/** \class SkBitmap
(this->colorType() != kIndex_8_SkColorType || fColorTable);
}
- /** Returns the pixelRef's texture, or NULL
- */
- GrTexture* getTexture() const;
+#ifdef SK_SUPPORT_LEGACY_BITMAP_GETTEXTURE
+ GrTexture* getTexture() const { return nullptr; }
+#endif
/** Return the bitmap's colortable, if it uses one (i.e. colorType is
Index_8) and the pixels are locked.
/** Populates dst with the pixels of this pixelRef, converting them to colorType. */
bool readPixels(SkBitmap* dst, SkColorType colorType, const SkIRect* subset = NULL);
- /**
- * Makes a deep copy of this PixelRef, respecting the requested config.
- * @param colorType Desired colortype.
- * @param profileType Desired colorprofiletype.
- * @param subset Subset of this PixelRef to copy. Must be fully contained within the bounds of
- * of this PixelRef.
- * @return A new SkPixelRef, or NULL if either there is an error (e.g. the destination could
- * not be created with the given config), or this PixelRef does not support deep
- * copies.
- */
- virtual SkPixelRef* deepCopy(SkColorType, SkColorSpace*, const SkIRect* /*subset*/) {
- return NULL;
- }
-
// Register a listener that may be called the next time our generation ID changes.
//
// We'll only call the listener if we're confident that we are the only SkPixelRef with this
GrTexture* GrRefCachedBitmapTexture(GrContext*, const SkBitmap&, const GrTextureParams&,
SkSourceGammaTreatment);
+sk_sp<GrTexture> GrMakeCachedBitmapTexture(GrContext*, const SkBitmap&, const GrTextureParams&,
+ SkSourceGammaTreatment);
+
// TODO: Move SkImageInfo2GrPixelConfig to SkGrPriv.h (requires cleanup to SkWindow its subclasses).
GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType, SkAlphaType, const SkColorSpace*,
const GrCaps&);
}
}
-GrTexture* SkBitmap::getTexture() const {
- return fPixelRef ? fPixelRef->getTexture() : nullptr;
-}
-
///////////////////////////////////////////////////////////////////////////////
/** We explicitly use the same allocator for our pixels that SkMask does,
return false; // r is empty (i.e. no intersection)
}
- if (fPixelRef->getTexture() != nullptr) {
- // Do a deep copy
- SkPixelRef* pixelRef = fPixelRef->deepCopy(this->colorType(), this->colorSpace(), &subset);
- if (pixelRef != nullptr) {
- SkBitmap dst;
- dst.setInfo(this->info().makeWH(subset.width(), subset.height()));
- dst.setIsVolatile(this->isVolatile());
- dst.setPixelRef(pixelRef)->unref();
- SkDEBUGCODE(dst.validate());
- result->swap(dst);
- return true;
- }
- }
-
// If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
// exited above.
SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
return true;
}
+// TODO: can we merge this with copyTo?
bool SkBitmap::deepCopyTo(SkBitmap* dst) const {
const SkColorType dstCT = this->colorType();
- SkColorSpace* dstCS = this->colorSpace();
if (!this->canCopyTo(dstCT)) {
return false;
}
-
- // If we have a PixelRef, and it supports deep copy, use it.
- // Currently supported only by texture-backed bitmaps.
- if (fPixelRef) {
- SkPixelRef* pixelRef = fPixelRef->deepCopy(dstCT, dstCS, nullptr);
- if (pixelRef) {
- uint32_t rowBytes;
- if (this->colorType() == dstCT && this->colorSpace() == dstCS) {
- // Since there is no subset to pass to deepCopy, and deepCopy
- // succeeded, the new pixel ref must be identical.
- SkASSERT(fPixelRef->info() == pixelRef->info());
- pixelRef->cloneGenID(*fPixelRef);
- // Use the same rowBytes as the original.
- rowBytes = fRowBytes;
- } else {
- // With the new config, an appropriate fRowBytes will be computed by setInfo.
- rowBytes = 0;
- }
-
- const SkImageInfo info = fInfo.makeColorType(dstCT);
- if (!dst->setInfo(info, rowBytes)) {
- return false;
- }
- dst->setPixelRef(pixelRef, fPixelRefOrigin)->unref();
- return true;
- }
- }
-
- if (this->getTexture()) {
- return false;
- } else {
- return this->copyTo(dst, dstCT, nullptr);
- }
+ return this->copyTo(dst, dstCT, nullptr);
}
///////////////////////////////////////////////////////////////////////////////
if (nullptr == fBitmap.pixelRef()) {
return false; // no pixels to read
}
- if (fBitmap.getTexture()) {
- // we can handle texture (ugh) since lockPixels will perform a read-back
- return true;
- }
if (kIndex_8_SkColorType == fBitmap.colorType()) {
SkAutoLockPixels alp(fBitmap); // but we need to call it before getColorTable() is safe.
if (!fBitmap.getColorTable()) {
}
bool SkCanvas::readPixels(SkBitmap* bitmap, int x, int y) {
- if (kUnknown_SkColorType == bitmap->colorType() || bitmap->getTexture()) {
+ if (kUnknown_SkColorType == bitmap->colorType()) {
return false;
}
}
bool SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y) {
- if (bitmap.getTexture()) {
- return false;
- }
-
SkAutoPixmapUnlock unlocker;
if (bitmap.requestLock(&unlocker)) {
const SkPixmap& pm = unlocker.pixmap();
sk_sp<SkSpecialImage> SkSpecialImage::MakeFromRaster(const SkIRect& subset,
const SkBitmap& bm,
const SkSurfaceProps* props) {
- SkASSERT(nullptr == bm.getTexture());
SkASSERT(rect_fits(subset, bm.width(), bm.height()));
const SkBitmap* srcBM = &bm;
static bool bmp_is_alpha_only(const SkBitmap& bm) { return kAlpha_8_SkColorType == bm.colorType(); }
-GrBitmapTextureAdjuster::GrBitmapTextureAdjuster(const SkBitmap* bmp)
- : INHERITED(bmp->getTexture(),
- SkIRect::MakeWH(bmp->width(), bmp->height()),
- bmp_is_alpha_only(*bmp))
- , fBmp(bmp) {}
-
-void GrBitmapTextureAdjuster::makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) {
- if (fBmp->isVolatile()) {
- return;
- }
- // The content area must represent the whole bitmap. Texture-backed bitmaps don't support
- // extractSubset(). Therefore, either the bitmap and the texture are the same size or the
- // content's dimensions are the bitmap's dimensions which is pinned to the upper left
- // of the texture.
- GrUniqueKey baseKey;
- GrMakeKeyFromImageID(&baseKey, fBmp->getGenerationID(),
- SkIRect::MakeWH(fBmp->width(), fBmp->height()));
- MakeCopyKeyFromOrigKey(baseKey, params, copyKey);
-}
-
-void GrBitmapTextureAdjuster::didCacheCopy(const GrUniqueKey& copyKey) {
- GrInstallBitmapUniqueKeyInvalidator(copyKey, fBmp->pixelRef());
-}
-
-SkColorSpace* GrBitmapTextureAdjuster::getColorSpace() {
- return fBmp->colorSpace();
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
// SkImage's don't have a way of communicating whether they're alpha-only. So we fallback to
// inspecting the texture.
static bool tex_image_is_alpha_only(const SkImage_Base& img) {
GrBitmapTextureMaker::GrBitmapTextureMaker(GrContext* context, const SkBitmap& bitmap)
: INHERITED(context, bitmap.width(), bitmap.height(), bmp_is_alpha_only(bitmap))
- , fBitmap(bitmap) {
- SkASSERT(!bitmap.getTexture());
+ , fBitmap(bitmap)
+{
if (!bitmap.isVolatile()) {
SkIPoint origin = bitmap.pixelRefOrigin();
SkIRect subset = SkIRect::MakeXYWH(origin.fX, origin.fY, bitmap.width(),
class SkImage_Base;
class SkImageCacherator;
-/** Implementation for texture-backed SkBitmaps. The bitmap must stay in scope and unmodified
- while this object exists. */
-class GrBitmapTextureAdjuster : public GrTextureAdjuster {
-public:
- explicit GrBitmapTextureAdjuster(const SkBitmap* bmp);
-
-protected:
- SkColorSpace* getColorSpace() override;
-
-private:
- void makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) override;
-
- void didCacheCopy(const GrUniqueKey& copyKey) override;
-
- const SkBitmap* fBmp;
-
- typedef GrTextureAdjuster INHERITED;
-};
-
/** Implementation for texture-backed SkImages. The image must stay in scope and unmodified while
this object exists. */
class GrImageTextureAdjuster : public GrTextureAdjuster {
///////////////////////////////////////////////////////////////////////////////
-// Helper for turning a bitmap into a texture. If the bitmap is GrTexture backed this
-// just accesses the backing GrTexture. Otherwise, it creates a cached texture
-// representation and releases it in the destructor.
-class AutoBitmapTexture : public SkNoncopyable {
-public:
- AutoBitmapTexture() {}
-
- AutoBitmapTexture(GrContext* context,
- const SkBitmap& bitmap,
- const GrTextureParams& params,
- SkSourceGammaTreatment gammaTreatment,
- GrTexture** texture) {
- SkASSERT(texture);
- *texture = this->set(context, bitmap, params, gammaTreatment);
- }
-
- GrTexture* set(GrContext* context,
- const SkBitmap& bitmap,
- const GrTextureParams& params,
- SkSourceGammaTreatment gammaTreatment) {
- // Either get the texture directly from the bitmap, or else use the cache and
- // remember to unref it.
- if (GrTexture* bmpTexture = bitmap.getTexture()) {
- fTexture.reset(nullptr);
- return bmpTexture;
- } else {
- fTexture.reset(GrRefCachedBitmapTexture(context, bitmap, params, gammaTreatment));
- return fTexture.get();
- }
- }
-
-private:
- SkAutoTUnref<GrTexture> fTexture;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
/** Checks that the alpha type is legal and gets constructor flags. Returns false if device creation
should fail. */
bool SkGpuDevice::CheckAlphaTypeAndGetFlags(
int* tileSize,
SkIRect* clippedSrcRect) const {
ASSERT_SINGLE_OWNER
- // if bitmap is explictly texture backed then just use the texture
- if (bitmap.getTexture()) {
- return false;
- }
-
return this->shouldTileImageID(bitmap.getGenerationID(), bitmap.getSubset(), viewMatrix, params,
srcRectPtr, maxTileSize, tileSize, clippedSrcRect);
}
CHECK_SHOULD_DRAW(origDraw);
SkMatrix viewMatrix;
viewMatrix.setConcat(*origDraw.fMatrix, m);
- if (bitmap.getTexture()) {
- GrBitmapTextureAdjuster adjuster(&bitmap);
- // We can use kFast here because we know texture-backed bitmaps don't support extractSubset.
- this->drawTextureProducer(&adjuster, nullptr, nullptr, SkCanvas::kFast_SrcRectConstraint,
- viewMatrix, fClip, paint);
- return;
- }
+
int maxTileSize = fContext->caps()->maxTileSize();
// The tile code path doesn't currently support AA, so if the paint asked for aa and we could
// We should have already handled bitmaps larger than the max texture size.
SkASSERT(bitmap.width() <= fContext->caps()->maxTextureSize() &&
bitmap.height() <= fContext->caps()->maxTextureSize());
- // Unless the bitmap is inherently texture-backed, we should be respecting the max tile size
- // by the time we get here.
- SkASSERT(bitmap.getTexture() ||
- (bitmap.width() <= fContext->caps()->maxTileSize() &&
- bitmap.height() <= fContext->caps()->maxTileSize()));
+ // We should be respecting the max tile size by the time we get here.
+ SkASSERT(bitmap.width() <= fContext->caps()->maxTileSize() &&
+ bitmap.height() <= fContext->caps()->maxTileSize());
- GrTexture* texture;
SkSourceGammaTreatment gammaTreatment = this->surfaceProps().isGammaCorrect()
? SkSourceGammaTreatment::kRespect : SkSourceGammaTreatment::kIgnore;
- AutoBitmapTexture abt(fContext, bitmap, params, gammaTreatment, &texture);
+ sk_sp<GrTexture> texture = GrMakeCachedBitmapTexture(fContext, bitmap, params, gammaTreatment);
if (nullptr == texture) {
return;
}
}
textureDomain.setLTRB(left, top, right, bottom);
if (bicubic) {
- fp = GrBicubicEffect::Make(texture, std::move(colorSpaceXform), texMatrix,
+ fp = GrBicubicEffect::Make(texture.get(), std::move(colorSpaceXform), texMatrix,
textureDomain);
} else {
- fp = GrTextureDomainEffect::Make(texture, std::move(colorSpaceXform), texMatrix,
+ fp = GrTextureDomainEffect::Make(texture.get(), std::move(colorSpaceXform), texMatrix,
textureDomain, GrTextureDomain::kClamp_Mode,
params.filterMode());
}
} else if (bicubic) {
SkASSERT(GrTextureParams::kNone_FilterMode == params.filterMode());
SkShader::TileMode tileModes[2] = { params.getTileModeX(), params.getTileModeY() };
- fp = GrBicubicEffect::Make(texture, std::move(colorSpaceXform), texMatrix, tileModes);
+ fp = GrBicubicEffect::Make(texture.get(), std::move(colorSpaceXform), texMatrix, tileModes);
} else {
- fp = GrSimpleTextureEffect::Make(texture, std::move(colorSpaceXform), texMatrix, params);
+ fp = GrSimpleTextureEffect::Make(texture.get(), std::move(colorSpaceXform), texMatrix, params);
}
GrPaint grPaint;
return;
}
- sk_sp<GrTexture> texture = sk_ref_sp(bitmap.getTexture());
- if (!texture) {
+ sk_sp<GrTexture> texture;
+ {
SkAutoLockPixels alp(bitmap, true);
if (!bitmap.readyToDraw()) {
return;
const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
ASSERT_SINGLE_OWNER
CHECK_SHOULD_DRAW(draw);
- if (bitmap.getTexture()) {
- GrBitmapTextureAdjuster adjuster(&bitmap);
- this->drawTextureProducer(&adjuster, src, &origDst, constraint, *draw.fMatrix, fClip,
- paint);
- return;
- }
+
// The src rect is inferred to be the bmp bounds if not provided. Otherwise, the src rect must
// be clipped to the bmp bounds. To determine tiling parameters we need the filter mode which
// in turn requires knowing the src-to-dst mapping. If the src was clipped to the bmp bounds
}
sk_sp<SkSpecialImage> SkGpuDevice::makeSpecial(const SkBitmap& bitmap) {
- SkASSERT(!bitmap.getTexture());
-
SkAutoLockPixels alp(bitmap, true);
if (!bitmap.readyToDraw()) {
return nullptr;
}
- GrTexture* texture;
- AutoBitmapTexture abt(fContext, bitmap, GrTextureParams::ClampNoFilter(),
- SkSourceGammaTreatment::kRespect, &texture);
+ sk_sp<GrTexture> texture = GrMakeCachedBitmapTexture(fContext, bitmap,
+ GrTextureParams::ClampNoFilter(),
+ SkSourceGammaTreatment::kRespect);
if (!texture) {
return nullptr;
}
return SkSpecialImage::MakeFromGpu(bitmap.bounds(),
bitmap.getGenerationID(),
- sk_ref_sp(texture),
+ texture,
sk_ref_sp(bitmap.colorSpace()),
&this->surfaceProps());
}
void SkGpuDevice::drawBitmapNine(const SkDraw& draw, const SkBitmap& bitmap, const SkIRect& center,
const SkRect& dst, const SkPaint& paint) {
ASSERT_SINGLE_OWNER
- if (bitmap.getTexture()) {
- GrBitmapTextureAdjuster adjuster(&bitmap);
- this->drawProducerNine(draw, &adjuster, center, dst, paint);
- } else {
- GrBitmapTextureMaker maker(fContext, bitmap);
- this->drawProducerNine(draw, &maker, center, dst, paint);
- }
+ GrBitmapTextureMaker maker(fContext, bitmap);
+ this->drawProducerNine(draw, &maker, center, dst, paint);
}
///////////////////////////////////////////////////////////////////////////////
GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
const GrTextureParams& params,
SkSourceGammaTreatment gammaTreatment) {
- if (bitmap.getTexture()) {
- return GrBitmapTextureAdjuster(&bitmap).refTextureSafeForParams(params, gammaTreatment,
- nullptr);
- }
return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, gammaTreatment);
}
+sk_sp<GrTexture> GrMakeCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
+ const GrTextureParams& params,
+ SkSourceGammaTreatment gammaTreatment) {
+ GrTexture* tex = GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params, gammaTreatment);
+ return sk_sp<GrTexture>(tex);
+}
+
///////////////////////////////////////////////////////////////////////////////
// alphatype is ignore for now, but if GrPixelConfig is expanded to encompass
}
sk_sp<SkImage> SkMakeImageFromRasterBitmap(const SkBitmap& bm, ForceCopyMode forceCopy) {
- SkASSERT(nullptr == bm.getTexture());
-
bool hasColorTable = false;
if (kIndex_8_SkColorType == bm.colorType()) {
SkAutoLockPixels autoLockPixels(bm);
namespace sk_tools {
void force_all_opaque(const SkBitmap& bitmap) {
- SkASSERT(nullptr == bitmap.getTexture());
SkASSERT(kN32_SkColorType == bitmap.colorType());
- if (bitmap.getTexture() || kN32_SkColorType == bitmap.colorType()) {
+ if (kN32_SkColorType == bitmap.colorType()) {
return;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff