reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Herb Derby | ac04fef | 2017-01-13 17:34:33 -0500 | [diff] [blame] | 8 | #include "SkArenaAlloc.h" |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 9 | #include "SkBitmapController.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 10 | #include "SkBitmapProcShader.h" |
| 11 | #include "SkBitmapProvider.h" |
Mike Klein | e28a6b5 | 2018-07-25 13:05:17 -0400 | [diff] [blame] | 12 | #include "SkColorSpacePriv.h" |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 13 | #include "SkColorSpaceXformSteps.h" |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 14 | #include "SkEmptyShader.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 15 | #include "SkImage_Base.h" |
| 16 | #include "SkImageShader.h" |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 17 | #include "SkPM4fPriv.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 18 | #include "SkReadBuffer.h" |
| 19 | #include "SkWriteBuffer.h" |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 20 | #include "../jumper/SkJumper.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 21 | |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 22 | /** |
| 23 | * We are faster in clamp, so always use that tiling when we can. |
| 24 | */ |
| 25 | static SkShader::TileMode optimize(SkShader::TileMode tm, int dimension) { |
| 26 | SkASSERT(dimension > 0); |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 27 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 28 | // need to update frameworks/base/libs/hwui/tests/unit/SkiaBehaviorTests.cpp:55 to allow |
| 29 | // for transforming to clamp. |
| 30 | return tm; |
| 31 | #else |
Mike Reed | cbbb58a | 2017-06-24 20:32:27 +0000 | [diff] [blame] | 32 | return dimension == 1 ? SkShader::kClamp_TileMode : tm; |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 33 | #endif |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 34 | } |
| 35 | |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 36 | SkImageShader::SkImageShader(sk_sp<SkImage> img, |
| 37 | TileMode tmx, TileMode tmy, |
| 38 | const SkMatrix* localMatrix, |
| 39 | bool clampAsIfUnpremul) |
| 40 | : INHERITED(localMatrix) |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 41 | , fImage(std::move(img)) |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 42 | , fTileModeX(optimize(tmx, fImage->width())) |
| 43 | , fTileModeY(optimize(tmy, fImage->height())) |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 44 | , fClampAsIfUnpremul(clampAsIfUnpremul) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 45 | {} |
| 46 | |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 47 | // fClampAsIfUnpremul is always false when constructed through public APIs, |
| 48 | // so there's no need to read or write it here. |
| 49 | |
reed | 60c9b58 | 2016-04-03 09:11:13 -0700 | [diff] [blame] | 50 | sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 51 | const TileMode tx = (TileMode)buffer.readUInt(); |
| 52 | const TileMode ty = (TileMode)buffer.readUInt(); |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 53 | SkMatrix localMatrix; |
| 54 | buffer.readMatrix(&localMatrix); |
reed | a9ca05c | 2016-08-11 03:55:15 -0700 | [diff] [blame] | 55 | sk_sp<SkImage> img = buffer.readImage(); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 56 | if (!img) { |
| 57 | return nullptr; |
| 58 | } |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 59 | return SkImageShader::Make(std::move(img), tx, ty, &localMatrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | void SkImageShader::flatten(SkWriteBuffer& buffer) const { |
| 63 | buffer.writeUInt(fTileModeX); |
| 64 | buffer.writeUInt(fTileModeY); |
| 65 | buffer.writeMatrix(this->getLocalMatrix()); |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 66 | buffer.writeImage(fImage.get()); |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 67 | SkASSERT(fClampAsIfUnpremul == false); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 68 | } |
| 69 | |
| 70 | bool SkImageShader::isOpaque() const { |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 71 | return fImage->isOpaque() && fTileModeX != kDecal_TileMode && fTileModeY != kDecal_TileMode; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 72 | } |
| 73 | |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 74 | static bool legacy_shader_can_handle(const SkMatrix& inv) { |
| 75 | if (!inv.isScaleTranslate()) { |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 76 | return false; |
| 77 | } |
| 78 | |
| 79 | // legacy code uses SkFixed 32.32, so ensure the inverse doesn't map device coordinates |
| 80 | // out of range. |
| 81 | const SkScalar max_dev_coord = 32767.0f; |
| 82 | SkRect src; |
| 83 | SkAssertResult(inv.mapRect(&src, SkRect::MakeWH(max_dev_coord, max_dev_coord))); |
| 84 | |
Mike Reed | 1eb5ca4 | 2018-03-08 14:20:52 -0500 | [diff] [blame] | 85 | // take 1/4 of max signed 32bits so we have room to subtract local values |
| 86 | const SkScalar max_fixed32dot32 = SK_MaxS32 * 0.25f; |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 87 | if (!SkRect::MakeLTRB(-max_fixed32dot32, -max_fixed32dot32, |
| 88 | max_fixed32dot32, max_fixed32dot32).contains(src)) { |
| 89 | return false; |
| 90 | } |
| 91 | |
| 92 | // legacy shader impl should be able to handle these matrices |
| 93 | return true; |
| 94 | } |
| 95 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 96 | SkShaderBase::Context* SkImageShader::onMakeContext(const ContextRec& rec, |
| 97 | SkArenaAlloc* alloc) const { |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 98 | const auto info = as_IB(fImage)->onImageInfo(); |
| 99 | |
| 100 | if (info.colorType() != kN32_SkColorType) { |
| 101 | return nullptr; |
| 102 | } |
| 103 | if (info.alphaType() == kUnpremul_SkAlphaType) { |
| 104 | return nullptr; |
| 105 | } |
| 106 | #ifndef SK_SUPPORT_LEGACY_TILED_BITMAPS |
| 107 | if (fTileModeX != fTileModeY) { |
| 108 | return nullptr; |
| 109 | } |
| 110 | #endif |
| 111 | if (fTileModeX == kDecal_TileMode || fTileModeY == kDecal_TileMode) { |
| 112 | return nullptr; |
| 113 | } |
| 114 | |
| 115 | SkMatrix inv; |
| 116 | if (!this->computeTotalInverse(*rec.fMatrix, rec.fLocalMatrix, &inv) || |
| 117 | !legacy_shader_can_handle(inv)) { |
| 118 | return nullptr; |
| 119 | } |
| 120 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 121 | return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY, |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 122 | SkBitmapProvider(fImage.get()), rec, alloc); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 123 | } |
| 124 | |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 125 | SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const { |
| 126 | if (texM) { |
| 127 | *texM = this->getLocalMatrix(); |
| 128 | } |
| 129 | if (xy) { |
| 130 | xy[0] = (TileMode)fTileModeX; |
| 131 | xy[1] = (TileMode)fTileModeY; |
| 132 | } |
| 133 | return const_cast<SkImage*>(fImage.get()); |
| 134 | } |
| 135 | |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 136 | #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 137 | bool SkImageShader::onIsABitmap(SkBitmap* texture, SkMatrix* texM, TileMode xy[]) const { |
| 138 | const SkBitmap* bm = as_IB(fImage)->onPeekBitmap(); |
| 139 | if (!bm) { |
| 140 | return false; |
| 141 | } |
| 142 | |
| 143 | if (texture) { |
| 144 | *texture = *bm; |
| 145 | } |
| 146 | if (texM) { |
| 147 | *texM = this->getLocalMatrix(); |
| 148 | } |
| 149 | if (xy) { |
| 150 | xy[0] = (TileMode)fTileModeX; |
| 151 | xy[1] = (TileMode)fTileModeY; |
| 152 | } |
| 153 | return true; |
| 154 | } |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 155 | #endif |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 156 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 157 | static bool bitmap_is_too_big(int w, int h) { |
| 158 | // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it |
| 159 | // communicates between its matrix-proc and its sampler-proc. Until we can |
| 160 | // widen that, we have to reject bitmaps that are larger. |
| 161 | // |
| 162 | static const int kMaxSize = 65535; |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 163 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 164 | return w > kMaxSize || h > kMaxSize; |
| 165 | } |
| 166 | |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 167 | sk_sp<SkShader> SkImageShader::Make(sk_sp<SkImage> image, |
| 168 | TileMode tx, TileMode ty, |
| 169 | const SkMatrix* localMatrix, |
| 170 | bool clampAsIfUnpremul) { |
Robert Phillips | 54be5c9 | 2017-02-11 01:19:30 +0000 | [diff] [blame] | 171 | if (!image || bitmap_is_too_big(image->width(), image->height())) { |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 172 | return sk_make_sp<SkEmptyShader>(); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 173 | } |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 174 | return sk_sp<SkShader>{ new SkImageShader(image, tx,ty, localMatrix, clampAsIfUnpremul) }; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 175 | } |
| 176 | |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 177 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 178 | |
| 179 | #if SK_SUPPORT_GPU |
| 180 | |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 181 | #include "GrColorSpaceInfo.h" |
Robert Phillips | 296b1cc | 2017-03-15 10:42:12 -0400 | [diff] [blame] | 182 | #include "GrContext.h" |
Brian Osman | db78cba | 2018-02-15 10:09:48 -0500 | [diff] [blame] | 183 | #include "GrContextPriv.h" |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 184 | #include "SkGr.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 185 | #include "effects/GrBicubicEffect.h" |
| 186 | #include "effects/GrSimpleTextureEffect.h" |
| 187 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 188 | static GrSamplerState::WrapMode tile_mode_to_wrap_mode(const SkShader::TileMode tileMode) { |
| 189 | switch (tileMode) { |
| 190 | case SkShader::TileMode::kClamp_TileMode: |
| 191 | return GrSamplerState::WrapMode::kClamp; |
| 192 | case SkShader::TileMode::kRepeat_TileMode: |
| 193 | return GrSamplerState::WrapMode::kRepeat; |
| 194 | case SkShader::TileMode::kMirror_TileMode: |
| 195 | return GrSamplerState::WrapMode::kMirrorRepeat; |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 196 | case SkShader::kDecal_TileMode: |
| 197 | // TODO: depending on caps, we should extend WrapMode for decal... |
| 198 | return GrSamplerState::WrapMode::kClamp; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 199 | } |
| 200 | SK_ABORT("Unknown tile mode."); |
| 201 | return GrSamplerState::WrapMode::kClamp; |
| 202 | } |
| 203 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 204 | std::unique_ptr<GrFragmentProcessor> SkImageShader::asFragmentProcessor( |
Mike Reed | e3429e6 | 2018-01-19 11:43:34 -0500 | [diff] [blame] | 205 | const GrFPArgs& args) const { |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 206 | const auto lm = this->totalLocalMatrix(args.fPreLocalMatrix, args.fPostLocalMatrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 207 | SkMatrix lmInverse; |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 208 | if (!lm->invert(&lmInverse)) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 209 | return nullptr; |
| 210 | } |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 211 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 212 | GrSamplerState::WrapMode wrapModes[] = {tile_mode_to_wrap_mode(fTileModeX), |
| 213 | tile_mode_to_wrap_mode(fTileModeY)}; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 214 | |
| 215 | // Must set wrap and filter on the sampler before requesting a texture. In two places below |
| 216 | // we check the matrix scale factors to determine how to interpret the filter quality setting. |
| 217 | // This completely ignores the complexity of the drawVertices case where explicit local coords |
| 218 | // are provided by the caller. |
| 219 | bool doBicubic; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 220 | GrSamplerState::Filter textureFilterMode = GrSkFilterQualityToGrFilterMode( |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 221 | args.fFilterQuality, *args.fViewMatrix, *lm, |
Brian Osman | db78cba | 2018-02-15 10:09:48 -0500 | [diff] [blame] | 222 | args.fContext->contextPriv().sharpenMipmappedTextures(), &doBicubic); |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 223 | GrSamplerState samplerState(wrapModes, textureFilterMode); |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 224 | sk_sp<SkColorSpace> texColorSpace; |
Robert Phillips | 67c18d6 | 2017-01-20 12:44:06 -0500 | [diff] [blame] | 225 | SkScalar scaleAdjust[2] = { 1.0f, 1.0f }; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 226 | sk_sp<GrTextureProxy> proxy(as_IB(fImage)->asTextureProxyRef( |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 227 | args.fContext, samplerState, args.fDstColorSpaceInfo->colorSpace(), &texColorSpace, |
| 228 | scaleAdjust)); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 229 | if (!proxy) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 230 | return nullptr; |
| 231 | } |
| 232 | |
Brian Osman | f06ead9 | 2017-10-30 13:47:41 -0400 | [diff] [blame] | 233 | GrPixelConfig config = proxy->config(); |
| 234 | bool isAlphaOnly = GrPixelConfigIsAlphaOnly(config); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 235 | |
Robert Phillips | 67c18d6 | 2017-01-20 12:44:06 -0500 | [diff] [blame] | 236 | lmInverse.postScale(scaleAdjust[0], scaleAdjust[1]); |
| 237 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 238 | std::unique_ptr<GrFragmentProcessor> inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 239 | if (doBicubic) { |
Brian Osman | 5e34167 | 2017-10-18 10:23:18 -0400 | [diff] [blame] | 240 | inner = GrBicubicEffect::Make(std::move(proxy), lmInverse, wrapModes); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 241 | } else { |
Brian Osman | 2240be9 | 2017-10-18 13:15:13 -0400 | [diff] [blame] | 242 | inner = GrSimpleTextureEffect::Make(std::move(proxy), lmInverse, samplerState); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 243 | } |
Brian Osman | 653f34d | 2018-06-14 11:44:02 -0400 | [diff] [blame] | 244 | inner = GrColorSpaceXformEffect::Make(std::move(inner), texColorSpace.get(), |
Brian Osman | 21fc5ce | 2018-08-27 20:36:19 +0000 | [diff] [blame] | 245 | fImage->alphaType(), |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 246 | args.fDstColorSpaceInfo->colorSpace()); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 247 | if (isAlphaOnly) { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 248 | return inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 249 | } |
Mike Reed | 28eaed2 | 2018-02-01 11:24:53 -0500 | [diff] [blame] | 250 | return GrFragmentProcessor::MulChildByInputAlpha(std::move(inner)); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | #endif |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 254 | |
| 255 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 256 | #include "SkImagePriv.h" |
| 257 | |
| 258 | sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, |
| 259 | SkShader::TileMode tmy, const SkMatrix* localMatrix, |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 260 | SkCopyPixelsMode cpm) { |
| 261 | return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm), |
| 262 | tmx, tmy, localMatrix); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 263 | } |
| 264 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 265 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShaderBase) |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 266 | SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkImageShader) |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 267 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
| 268 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 269 | bool SkImageShader::onAppendStages(const StageRec& rec) const { |
| 270 | SkRasterPipeline* p = rec.fPipeline; |
| 271 | SkArenaAlloc* alloc = rec.fAlloc; |
| 272 | |
Florin Malita | 7558e4d | 2018-02-07 10:05:53 -0500 | [diff] [blame] | 273 | SkMatrix matrix; |
| 274 | if (!this->computeTotalInverse(rec.fCTM, rec.fLocalM, &matrix)) { |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 275 | return false; |
| 276 | } |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 277 | auto quality = rec.fPaint.getFilterQuality(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 278 | |
Brian Osman | 2b23c4b | 2018-06-01 12:25:08 -0400 | [diff] [blame] | 279 | SkBitmapProvider provider(fImage.get()); |
Florin Malita | 84364ee | 2018-07-16 12:32:09 -0400 | [diff] [blame] | 280 | const auto* state = SkBitmapController::RequestBitmap(provider, matrix, quality, alloc); |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 281 | if (!state) { |
| 282 | return false; |
| 283 | } |
| 284 | |
| 285 | const SkPixmap& pm = state->pixmap(); |
| 286 | matrix = state->invMatrix(); |
| 287 | quality = state->quality(); |
| 288 | auto info = pm.info(); |
| 289 | |
Mike Klein | 7776029 | 2016-11-17 14:04:22 -0500 | [diff] [blame] | 290 | // When the matrix is just an integer translate, bilerp == nearest neighbor. |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 291 | if (quality == kLow_SkFilterQuality && |
| 292 | matrix.getType() <= SkMatrix::kTranslate_Mask && |
Mike Klein | 7776029 | 2016-11-17 14:04:22 -0500 | [diff] [blame] | 293 | matrix.getTranslateX() == (int)matrix.getTranslateX() && |
| 294 | matrix.getTranslateY() == (int)matrix.getTranslateY()) { |
| 295 | quality = kNone_SkFilterQuality; |
| 296 | } |
| 297 | |
Mike Klein | bf178a7 | 2016-11-17 15:56:24 -0500 | [diff] [blame] | 298 | // See skia:4649 and the GM image_scale_aligned. |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 299 | if (quality == kNone_SkFilterQuality) { |
| 300 | if (matrix.getScaleX() >= 0) { |
| 301 | matrix.setTranslateX(nextafterf(matrix.getTranslateX(), |
| 302 | floorf(matrix.getTranslateX()))); |
| 303 | } |
| 304 | if (matrix.getScaleY() >= 0) { |
| 305 | matrix.setTranslateY(nextafterf(matrix.getTranslateY(), |
| 306 | floorf(matrix.getTranslateY()))); |
| 307 | } |
| 308 | } |
| 309 | |
Mike Klein | e8de024 | 2018-03-10 12:37:11 -0500 | [diff] [blame] | 310 | p->append(SkRasterPipeline::seed_shader); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 311 | |
| 312 | struct MiscCtx { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 313 | SkColor4f paint_color; |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 314 | }; |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 315 | auto misc = alloc->make<MiscCtx>(); |
Robert Phillips | 4a17501 | 2018-07-13 13:18:56 +0000 | [diff] [blame] | 316 | swizzle_rb(Sk4f_fromL32(rec.fPaint.getColor())).store(misc->paint_color.vec()); // sRGBA floats |
Mike Reed | 6b59bf4 | 2017-07-03 21:26:44 -0400 | [diff] [blame] | 317 | p->append_matrix(alloc, matrix); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 318 | |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 319 | auto gather = alloc->make<SkJumper_GatherCtx>(); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 320 | gather->pixels = pm.addr(); |
Mike Klein | 968af43 | 2017-07-18 16:31:55 -0400 | [diff] [blame] | 321 | gather->stride = pm.rowBytesAsPixels(); |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 322 | gather->width = pm.width(); |
| 323 | gather->height = pm.height(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 324 | |
Mike Reed | 51e46d5 | 2017-06-23 14:21:25 -0400 | [diff] [blame] | 325 | auto limit_x = alloc->make<SkJumper_TileCtx>(), |
| 326 | limit_y = alloc->make<SkJumper_TileCtx>(); |
| 327 | limit_x->scale = pm.width(); |
| 328 | limit_x->invScale = 1.0f / pm.width(); |
| 329 | limit_y->scale = pm.height(); |
| 330 | limit_y->invScale = 1.0f / pm.height(); |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 331 | |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 332 | SkJumper_DecalTileCtx* decal_ctx = nullptr; |
| 333 | bool decal_x_and_y = fTileModeX == kDecal_TileMode && fTileModeY == kDecal_TileMode; |
| 334 | if (fTileModeX == kDecal_TileMode || fTileModeY == kDecal_TileMode) { |
| 335 | decal_ctx = alloc->make<SkJumper_DecalTileCtx>(); |
| 336 | decal_ctx->limit_x = limit_x->scale; |
| 337 | decal_ctx->limit_y = limit_y->scale; |
| 338 | } |
| 339 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 340 | auto append_tiling_and_gather = [&] { |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 341 | if (decal_x_and_y) { |
| 342 | p->append(SkRasterPipeline::decal_x_and_y, decal_ctx); |
| 343 | } else { |
| 344 | switch (fTileModeX) { |
| 345 | case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break; |
| 346 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x, limit_x); break; |
| 347 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x, limit_x); break; |
| 348 | case kDecal_TileMode: p->append(SkRasterPipeline::decal_x, decal_ctx); break; |
| 349 | } |
| 350 | switch (fTileModeY) { |
| 351 | case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break; |
| 352 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_y, limit_y); break; |
| 353 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_y, limit_y); break; |
| 354 | case kDecal_TileMode: p->append(SkRasterPipeline::decal_y, decal_ctx); break; |
| 355 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 356 | } |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 357 | |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 358 | void* ctx = gather; |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 359 | switch (info.colorType()) { |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 360 | case kAlpha_8_SkColorType: p->append(SkRasterPipeline::gather_a8, ctx); break; |
| 361 | case kGray_8_SkColorType: p->append(SkRasterPipeline::gather_g8, ctx); break; |
| 362 | case kRGB_565_SkColorType: p->append(SkRasterPipeline::gather_565, ctx); break; |
| 363 | case kARGB_4444_SkColorType: p->append(SkRasterPipeline::gather_4444, ctx); break; |
| 364 | case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::gather_bgra, ctx); break; |
| 365 | case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); break; |
| 366 | case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); break; |
| 367 | case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, ctx); break; |
Mike Klein | 3785471 | 2018-06-26 11:43:06 -0400 | [diff] [blame] | 368 | case kRGBA_F32_SkColorType: p->append(SkRasterPipeline::gather_f32, ctx); break; |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 369 | |
| 370 | case kRGB_888x_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); |
| 371 | p->append(SkRasterPipeline::force_opaque ); break; |
| 372 | case kRGB_101010x_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); |
| 373 | p->append(SkRasterPipeline::force_opaque ); break; |
| 374 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 375 | default: SkASSERT(false); |
| 376 | } |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 377 | if (decal_ctx) { |
| 378 | p->append(SkRasterPipeline::check_decal_mask, decal_ctx); |
| 379 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 380 | }; |
| 381 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 382 | auto append_misc = [&] { |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 383 | // TODO: if ref.fDstCS isn't null, we'll premul here then immediately unpremul |
| 384 | // to do the color space transformation. Might be possible to streamline. |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 385 | if (info.colorType() == kAlpha_8_SkColorType) { |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 386 | // The color for A8 images comes from the (sRGB) paint color. |
Mike Klein | 9fb5a53 | 2018-09-13 15:23:38 -0400 | [diff] [blame^] | 387 | // TODO: confirm that this is only ever called with the paint color set to black, |
| 388 | // then drop this step and the color correction below. |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 389 | p->append(SkRasterPipeline::set_rgb, &misc->paint_color); |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 390 | p->append(SkRasterPipeline::premul); |
| 391 | } else if (info.alphaType() == kUnpremul_SkAlphaType) { |
| 392 | // Convert unpremul images to premul before we carry on with the rest of the pipeline. |
Mike Klein | 47cf048 | 2018-02-09 18:57:54 +0000 | [diff] [blame] | 393 | p->append(SkRasterPipeline::premul); |
| 394 | } |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 395 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 396 | if (quality > kLow_SkFilterQuality) { |
| 397 | // Bicubic filtering naturally produces out of range values on both sides. |
| 398 | p->append(SkRasterPipeline::clamp_0); |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 399 | p->append(fClampAsIfUnpremul ? SkRasterPipeline::clamp_1 |
| 400 | : SkRasterPipeline::clamp_a); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 401 | } |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 402 | |
| 403 | if (rec.fDstCS) { |
| 404 | // If color managed, convert from premul source all the way to premul dst color space. |
| 405 | auto srcCS = info.colorSpace(); |
| 406 | if (!srcCS || info.colorType() == kAlpha_8_SkColorType) { |
| 407 | // We treat untagged images as sRGB. |
| 408 | // A8 images get their r,g,b from the paint color, so they're also sRGB. |
Mike Klein | e28a6b5 | 2018-07-25 13:05:17 -0400 | [diff] [blame] | 409 | srcCS = sk_srgb_singleton(); |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 410 | } |
Mike Klein | 8f3d36c | 2018-08-14 10:28:05 -0400 | [diff] [blame] | 411 | alloc->make<SkColorSpaceXformSteps>(srcCS , kPremul_SkAlphaType, |
| 412 | rec.fDstCS, kPremul_SkAlphaType) |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 413 | ->apply(p); |
| 414 | } |
| 415 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 416 | return true; |
| 417 | }; |
| 418 | |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 419 | // We've got a fast path for 8888 bilinear clamp/clamp sampling. |
Mike Klein | 8e3426f | 2018-04-16 12:56:24 -0400 | [diff] [blame] | 420 | auto ct = info.colorType(); |
| 421 | if (true |
| 422 | && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) |
| 423 | && quality == kLow_SkFilterQuality |
| 424 | && fTileModeX == SkShader::kClamp_TileMode |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 425 | && fTileModeY == SkShader::kClamp_TileMode) { |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 426 | |
| 427 | p->append(SkRasterPipeline::bilerp_clamp_8888, gather); |
Mike Klein | 8e3426f | 2018-04-16 12:56:24 -0400 | [diff] [blame] | 428 | if (ct == kBGRA_8888_SkColorType) { |
| 429 | p->append(SkRasterPipeline::swap_rb); |
| 430 | } |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 431 | return append_misc(); |
| 432 | } |
| 433 | |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 434 | SkJumper_SamplerCtx* sampler = nullptr; |
| 435 | if (quality != kNone_SkFilterQuality) { |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 436 | sampler = alloc->make<SkJumper_SamplerCtx>(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 437 | } |
| 438 | |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 439 | auto sample = [&](SkRasterPipeline::StockStage setup_x, |
| 440 | SkRasterPipeline::StockStage setup_y) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 441 | p->append(setup_x, sampler); |
| 442 | p->append(setup_y, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 443 | append_tiling_and_gather(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 444 | p->append(SkRasterPipeline::accumulate, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 445 | }; |
| 446 | |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 447 | if (quality == kNone_SkFilterQuality) { |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 448 | append_tiling_and_gather(); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 449 | |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 450 | } else if (quality == kLow_SkFilterQuality) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 451 | p->append(SkRasterPipeline::save_xy, sampler); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 452 | |
| 453 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_ny); |
| 454 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_ny); |
| 455 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_py); |
| 456 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_py); |
| 457 | |
| 458 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 459 | |
Mike Klein | 46e66a2 | 2016-11-21 16:19:34 -0500 | [diff] [blame] | 460 | } else { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 461 | p->append(SkRasterPipeline::save_xy, sampler); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 462 | |
| 463 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n3y); |
| 464 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n3y); |
| 465 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n3y); |
| 466 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n3y); |
| 467 | |
| 468 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n1y); |
| 469 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n1y); |
| 470 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n1y); |
| 471 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n1y); |
| 472 | |
| 473 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p1y); |
| 474 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p1y); |
| 475 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p1y); |
| 476 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p1y); |
| 477 | |
| 478 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p3y); |
| 479 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p3y); |
| 480 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p3y); |
| 481 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p3y); |
| 482 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 483 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 484 | } |
| 485 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 486 | return append_misc(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 487 | } |