| /* |
| * Copyright 2014 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkPictureShader.h" |
| |
| #include "SkAtomics.h" |
| #include "SkArenaAlloc.h" |
| #include "SkBitmap.h" |
| #include "SkBitmapProcShader.h" |
| #include "SkCanvas.h" |
| #include "SkColorSpaceXformCanvas.h" |
| #include "SkImage.h" |
| #include "SkImageShader.h" |
| #include "SkMatrixUtils.h" |
| #include "SkPicturePriv.h" |
| #include "SkReadBuffer.h" |
| #include "SkResourceCache.h" |
| |
| #if SK_SUPPORT_GPU |
| #include "GrCaps.h" |
| #include "GrColorSpaceInfo.h" |
| #include "GrContext.h" |
| #include "GrContextPriv.h" |
| #include "GrFragmentProcessor.h" |
| #include "SkGr.h" |
| #endif |
| |
| namespace { |
| static unsigned gBitmapShaderKeyNamespaceLabel; |
| |
| struct BitmapShaderKey : public SkResourceCache::Key { |
| public: |
| BitmapShaderKey(SkColorSpace* colorSpace, |
| SkImage::BitDepth bitDepth, |
| uint32_t shaderID, |
| const SkSize& scale) |
| : fColorSpaceXYZHash(colorSpace->toXYZD50Hash()) |
| , fColorSpaceTransferFnHash(colorSpace->transferFnHash()) |
| , fBitDepth(bitDepth) |
| , fScale(scale) { |
| |
| static const size_t keySize = sizeof(fColorSpaceXYZHash) + |
| sizeof(fColorSpaceTransferFnHash) + |
| sizeof(fBitDepth) + |
| sizeof(fScale); |
| // This better be packed. |
| SkASSERT(sizeof(uint32_t) * (&fEndOfStruct - &fColorSpaceXYZHash) == keySize); |
| this->init(&gBitmapShaderKeyNamespaceLabel, MakeSharedID(shaderID), keySize); |
| } |
| |
| static uint64_t MakeSharedID(uint32_t shaderID) { |
| uint64_t sharedID = SkSetFourByteTag('p', 's', 'd', 'r'); |
| return (sharedID << 32) | shaderID; |
| } |
| |
| private: |
| uint32_t fColorSpaceXYZHash; |
| uint32_t fColorSpaceTransferFnHash; |
| SkImage::BitDepth fBitDepth; |
| SkSize fScale; |
| |
| SkDEBUGCODE(uint32_t fEndOfStruct;) |
| }; |
| |
| struct BitmapShaderRec : public SkResourceCache::Rec { |
| BitmapShaderRec(const BitmapShaderKey& key, SkShader* tileShader) |
| : fKey(key) |
| , fShader(SkRef(tileShader)) {} |
| |
| BitmapShaderKey fKey; |
| sk_sp<SkShader> fShader; |
| |
| const Key& getKey() const override { return fKey; } |
| size_t bytesUsed() const override { |
| // Just the record overhead -- the actual pixels are accounted by SkImage_Lazy. |
| return sizeof(fKey) + sizeof(SkImageShader); |
| } |
| const char* getCategory() const override { return "bitmap-shader"; } |
| SkDiscardableMemory* diagnostic_only_getDiscardable() const override { return nullptr; } |
| |
| static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) { |
| const BitmapShaderRec& rec = static_cast<const BitmapShaderRec&>(baseRec); |
| sk_sp<SkShader>* result = reinterpret_cast<sk_sp<SkShader>*>(contextShader); |
| |
| *result = rec.fShader; |
| |
| // The bitmap shader is backed by an image generator, thus it can always re-generate its |
| // pixels if discarded. |
| return true; |
| } |
| }; |
| |
| static int32_t gNextID = 1; |
| uint32_t next_id() { |
| int32_t id; |
| do { |
| id = sk_atomic_inc(&gNextID); |
| } while (id == SK_InvalidGenID); |
| return static_cast<uint32_t>(id); |
| } |
| |
| } // namespace |
| |
| SkPictureShader::SkPictureShader(sk_sp<SkPicture> picture, TileMode tmx, TileMode tmy, |
| const SkMatrix* localMatrix, const SkRect* tile, |
| sk_sp<SkColorSpace> colorSpace) |
| : INHERITED(localMatrix) |
| , fPicture(std::move(picture)) |
| , fTile(tile ? *tile : fPicture->cullRect()) |
| , fTmx(tmx) |
| , fTmy(tmy) |
| , fColorSpace(std::move(colorSpace)) |
| , fUniqueID(next_id()) |
| , fAddedToCache(false) {} |
| |
| SkPictureShader::~SkPictureShader() { |
| if (fAddedToCache.load()) { |
| SkResourceCache::PostPurgeSharedID(BitmapShaderKey::MakeSharedID(fUniqueID)); |
| } |
| } |
| |
| sk_sp<SkShader> SkPictureShader::Make(sk_sp<SkPicture> picture, TileMode tmx, TileMode tmy, |
| const SkMatrix* localMatrix, const SkRect* tile) { |
| if (!picture || picture->cullRect().isEmpty() || (tile && tile->isEmpty())) { |
| return SkShader::MakeEmptyShader(); |
| } |
| return sk_sp<SkShader>(new SkPictureShader(std::move(picture), tmx, tmy, localMatrix, tile, |
| nullptr)); |
| } |
| |
| sk_sp<SkFlattenable> SkPictureShader::CreateProc(SkReadBuffer& buffer) { |
| SkMatrix lm; |
| buffer.readMatrix(&lm); |
| TileMode mx = (TileMode)buffer.read32(); |
| TileMode my = (TileMode)buffer.read32(); |
| SkRect tile; |
| buffer.readRect(&tile); |
| |
| sk_sp<SkPicture> picture; |
| |
| bool didSerialize = buffer.readBool(); |
| if (didSerialize) { |
| picture = SkPicturePriv::MakeFromBuffer(buffer); |
| } |
| return SkPictureShader::Make(picture, mx, my, &lm, &tile); |
| } |
| |
| void SkPictureShader::flatten(SkWriteBuffer& buffer) const { |
| buffer.writeMatrix(this->getLocalMatrix()); |
| buffer.write32(fTmx); |
| buffer.write32(fTmy); |
| buffer.writeRect(fTile); |
| |
| buffer.writeBool(true); |
| SkPicturePriv::Flatten(fPicture, buffer); |
| } |
| |
| // Returns a cached image shader, which wraps a single picture tile at the given |
| // CTM/local matrix. Also adjusts the local matrix for tile scaling. |
| sk_sp<SkShader> SkPictureShader::refBitmapShader(const SkMatrix& viewMatrix, |
| SkTCopyOnFirstWrite<SkMatrix>* localMatrix, |
| SkColorType dstColorType, |
| SkColorSpace* dstColorSpace, |
| const int maxTextureSize) const { |
| SkASSERT(fPicture && !fPicture->cullRect().isEmpty()); |
| |
| const SkMatrix m = SkMatrix::Concat(viewMatrix, **localMatrix); |
| |
| // Use a rotation-invariant scale |
| SkPoint scale; |
| // |
| // TODO: replace this with decomposeScale() -- but beware LayoutTest rebaselines! |
| // |
| if (!SkDecomposeUpper2x2(m, nullptr, &scale, nullptr)) { |
| // Decomposition failed, use an approximation. |
| scale.set(SkScalarSqrt(m.getScaleX() * m.getScaleX() + m.getSkewX() * m.getSkewX()), |
| SkScalarSqrt(m.getScaleY() * m.getScaleY() + m.getSkewY() * m.getSkewY())); |
| } |
| SkSize scaledSize = SkSize::Make(SkScalarAbs(scale.x() * fTile.width()), |
| SkScalarAbs(scale.y() * fTile.height())); |
| |
| // Clamp the tile size to about 4M pixels |
| static const SkScalar kMaxTileArea = 2048 * 2048; |
| SkScalar tileArea = scaledSize.width() * scaledSize.height(); |
| if (tileArea > kMaxTileArea) { |
| SkScalar clampScale = SkScalarSqrt(kMaxTileArea / tileArea); |
| scaledSize.set(scaledSize.width() * clampScale, |
| scaledSize.height() * clampScale); |
| } |
| #if SK_SUPPORT_GPU |
| // Scale down the tile size if larger than maxTextureSize for GPU Path or it should fail on create texture |
| if (maxTextureSize) { |
| if (scaledSize.width() > maxTextureSize || scaledSize.height() > maxTextureSize) { |
| SkScalar downScale = maxTextureSize / SkMaxScalar(scaledSize.width(), scaledSize.height()); |
| scaledSize.set(SkScalarFloorToScalar(scaledSize.width() * downScale), |
| SkScalarFloorToScalar(scaledSize.height() * downScale)); |
| } |
| } |
| #endif |
| |
| const SkISize tileSize = scaledSize.toCeil(); |
| if (tileSize.isEmpty()) { |
| return SkShader::MakeEmptyShader(); |
| } |
| |
| // The actual scale, compensating for rounding & clamping. |
| const SkSize tileScale = SkSize::Make(SkIntToScalar(tileSize.width()) / fTile.width(), |
| SkIntToScalar(tileSize.height()) / fTile.height()); |
| |
| // |fColorSpace| will only be set when using an SkColorSpaceXformCanvas to do pre-draw xforms. |
| // A non-null |dstColorSpace| indicates that the surface we're drawing to is tagged. In all |
| // cases, picture-backed images behave the same (using a tagged surface for rasterization), |
| // and (as sources) they require a valid color space, so default to sRGB. |
| |
| // With SkColorSpaceXformCanvas, the surface should never have a color space attached. |
| SkASSERT(!fColorSpace || !dstColorSpace); |
| |
| sk_sp<SkColorSpace> imgCS = dstColorSpace ? sk_ref_sp(dstColorSpace) |
| : fColorSpace ? fColorSpace |
| : SkColorSpace::MakeSRGB(); |
| SkImage::BitDepth bitDepth = |
| kRGBA_F16_SkColorType == dstColorType || kRGBA_F32_SkColorType == dstColorType |
| ? SkImage::BitDepth::kF16 : SkImage::BitDepth::kU8; |
| |
| BitmapShaderKey key(imgCS.get(), bitDepth, fUniqueID, tileScale); |
| |
| sk_sp<SkShader> tileShader; |
| if (!SkResourceCache::Find(key, BitmapShaderRec::Visitor, &tileShader)) { |
| SkMatrix tileMatrix; |
| tileMatrix.setRectToRect(fTile, SkRect::MakeIWH(tileSize.width(), tileSize.height()), |
| SkMatrix::kFill_ScaleToFit); |
| |
| sk_sp<SkImage> tileImage = SkImage::MakeFromPicture(fPicture, tileSize, &tileMatrix, |
| nullptr, bitDepth, std::move(imgCS)); |
| if (!tileImage) { |
| return nullptr; |
| } |
| |
| tileShader = tileImage->makeShader(fTmx, fTmy); |
| |
| SkResourceCache::Add(new BitmapShaderRec(key, tileShader.get())); |
| fAddedToCache.store(true); |
| } |
| |
| if (tileScale.width() != 1 || tileScale.height() != 1) { |
| localMatrix->writable()->preScale(1 / tileScale.width(), 1 / tileScale.height()); |
| } |
| |
| return tileShader; |
| } |
| |
| bool SkPictureShader::onAppendStages(const StageRec& rec) const { |
| auto lm = this->totalLocalMatrix(rec.fLocalM); |
| |
| // Keep bitmapShader alive by using alloc instead of stack memory |
| auto& bitmapShader = *rec.fAlloc->make<sk_sp<SkShader>>(); |
| bitmapShader = this->refBitmapShader(rec.fCTM, &lm, rec.fDstColorType, rec.fDstCS); |
| |
| if (!bitmapShader) { |
| return false; |
| } |
| |
| StageRec localRec = rec; |
| localRec.fLocalM = lm->isIdentity() ? nullptr : lm.get(); |
| |
| return as_SB(bitmapShader)->appendStages(localRec); |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////////// |
| |
| #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT |
| SkShaderBase::Context* SkPictureShader::onMakeContext(const ContextRec& rec, SkArenaAlloc* alloc) |
| const { |
| auto lm = this->totalLocalMatrix(rec.fLocalMatrix); |
| sk_sp<SkShader> bitmapShader = this->refBitmapShader(*rec.fMatrix, &lm, rec.fDstColorType, |
| rec.fDstColorSpace); |
| if (!bitmapShader) { |
| return nullptr; |
| } |
| |
| ContextRec localRec = rec; |
| localRec.fLocalMatrix = lm->isIdentity() ? nullptr : lm.get(); |
| |
| PictureShaderContext* ctx = |
| alloc->make<PictureShaderContext>(*this, localRec, std::move(bitmapShader), alloc); |
| if (nullptr == ctx->fBitmapShaderContext) { |
| ctx = nullptr; |
| } |
| return ctx; |
| } |
| #endif |
| |
| sk_sp<SkShader> SkPictureShader::onMakeColorSpace(SkColorSpaceXformer* xformer) const { |
| sk_sp<SkColorSpace> dstCS = xformer->dst(); |
| if (SkColorSpace::Equals(dstCS.get(), fColorSpace.get())) { |
| return sk_ref_sp(const_cast<SkPictureShader*>(this)); |
| } |
| |
| return sk_sp<SkPictureShader>(new SkPictureShader(fPicture, fTmx, fTmy, &this->getLocalMatrix(), |
| &fTile, std::move(dstCS))); |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////////////// |
| |
| SkPictureShader::PictureShaderContext::PictureShaderContext( |
| const SkPictureShader& shader, const ContextRec& rec, sk_sp<SkShader> bitmapShader, |
| SkArenaAlloc* alloc) |
| : INHERITED(shader, rec) |
| , fBitmapShader(std::move(bitmapShader)) |
| { |
| fBitmapShaderContext = as_SB(fBitmapShader)->makeContext(rec, alloc); |
| //if fBitmapShaderContext is null, we are invalid |
| } |
| |
| uint32_t SkPictureShader::PictureShaderContext::getFlags() const { |
| SkASSERT(fBitmapShaderContext); |
| return fBitmapShaderContext->getFlags(); |
| } |
| |
| void SkPictureShader::PictureShaderContext::shadeSpan(int x, int y, SkPMColor dstC[], int count) { |
| SkASSERT(fBitmapShaderContext); |
| fBitmapShaderContext->shadeSpan(x, y, dstC, count); |
| } |
| |
| #if SK_SUPPORT_GPU |
| std::unique_ptr<GrFragmentProcessor> SkPictureShader::asFragmentProcessor( |
| const GrFPArgs& args) const { |
| int maxTextureSize = 0; |
| if (args.fContext) { |
| maxTextureSize = args.fContext->contextPriv().caps()->maxTextureSize(); |
| } |
| |
| auto lm = this->totalLocalMatrix(args.fPreLocalMatrix, args.fPostLocalMatrix); |
| SkColorType dstColorType = kN32_SkColorType; |
| GrPixelConfigToColorType(args.fDstColorSpaceInfo->config(), &dstColorType); |
| sk_sp<SkShader> bitmapShader(this->refBitmapShader(*args.fViewMatrix, &lm, dstColorType, |
| args.fDstColorSpaceInfo->colorSpace(), |
| maxTextureSize)); |
| if (!bitmapShader) { |
| return nullptr; |
| } |
| |
| // We want to *reset* args.fPreLocalMatrix, not compose it. |
| GrFPArgs newArgs(args.fContext, args.fViewMatrix, args.fFilterQuality, args.fDstColorSpaceInfo); |
| newArgs.fPreLocalMatrix = lm.get(); |
| |
| return as_SB(bitmapShader)->asFragmentProcessor(newArgs); |
| } |
| #endif |