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" |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 12 | #include "SkEmptyShader.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 13 | #include "SkImage_Base.h" |
| 14 | #include "SkImageShader.h" |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 15 | #include "SkPM4fPriv.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 16 | #include "SkReadBuffer.h" |
| 17 | #include "SkWriteBuffer.h" |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 18 | #include "../jumper/SkJumper.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 19 | |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 20 | /** |
| 21 | * We are faster in clamp, so always use that tiling when we can. |
| 22 | */ |
| 23 | static SkShader::TileMode optimize(SkShader::TileMode tm, int dimension) { |
| 24 | SkASSERT(dimension > 0); |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 25 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 26 | // need to update frameworks/base/libs/hwui/tests/unit/SkiaBehaviorTests.cpp:55 to allow |
| 27 | // for transforming to clamp. |
| 28 | return tm; |
| 29 | #else |
Mike Reed | cbbb58a | 2017-06-24 20:32:27 +0000 | [diff] [blame] | 30 | return dimension == 1 ? SkShader::kClamp_TileMode : tm; |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 31 | #endif |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 32 | } |
| 33 | |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 34 | SkImageShader::SkImageShader(sk_sp<SkImage> img, TileMode tmx, TileMode tmy, const SkMatrix* matrix) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 35 | : INHERITED(matrix) |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 36 | , fImage(std::move(img)) |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 37 | , fTileModeX(optimize(tmx, fImage->width())) |
| 38 | , fTileModeY(optimize(tmy, fImage->height())) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 39 | {} |
| 40 | |
reed | 60c9b58 | 2016-04-03 09:11:13 -0700 | [diff] [blame] | 41 | sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 42 | const TileMode tx = (TileMode)buffer.readUInt(); |
| 43 | const TileMode ty = (TileMode)buffer.readUInt(); |
| 44 | SkMatrix matrix; |
| 45 | buffer.readMatrix(&matrix); |
reed | a9ca05c | 2016-08-11 03:55:15 -0700 | [diff] [blame] | 46 | sk_sp<SkImage> img = buffer.readImage(); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 47 | if (!img) { |
| 48 | return nullptr; |
| 49 | } |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 50 | return SkImageShader::Make(std::move(img), tx, ty, &matrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | void SkImageShader::flatten(SkWriteBuffer& buffer) const { |
| 54 | buffer.writeUInt(fTileModeX); |
| 55 | buffer.writeUInt(fTileModeY); |
| 56 | buffer.writeMatrix(this->getLocalMatrix()); |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 57 | buffer.writeImage(fImage.get()); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | bool SkImageShader::isOpaque() const { |
| 61 | return fImage->isOpaque(); |
| 62 | } |
| 63 | |
Mike Reed | 3404207 | 2017-08-08 16:29:22 -0400 | [diff] [blame] | 64 | bool SkImageShader::IsRasterPipelineOnly(const SkMatrix& ctm, SkColorType ct, SkAlphaType at, |
Mike Reed | eefe9f9 | 2017-08-21 11:39:15 -0400 | [diff] [blame] | 65 | SkShader::TileMode tx, SkShader::TileMode ty, |
| 66 | const SkMatrix& localM) { |
Mike Reed | 980e279 | 2017-06-21 13:15:58 -0700 | [diff] [blame] | 67 | if (ct != kN32_SkColorType) { |
| 68 | return true; |
| 69 | } |
Mike Klein | 0fddb2d | 2017-07-20 08:59:19 -0400 | [diff] [blame] | 70 | if (at == kUnpremul_SkAlphaType) { |
| 71 | return true; |
| 72 | } |
Florin Malita | 6274c42 | 2017-08-17 21:04:03 -0400 | [diff] [blame] | 73 | #ifndef SK_SUPPORT_LEGACY_TILED_BITMAPS |
Mike Reed | bc4c26b | 2017-06-23 15:28:31 -0400 | [diff] [blame] | 74 | if (tx != ty) { |
Mike Reed | 980e279 | 2017-06-21 13:15:58 -0700 | [diff] [blame] | 75 | return true; |
| 76 | } |
Florin Malita | 6274c42 | 2017-08-17 21:04:03 -0400 | [diff] [blame] | 77 | #endif |
Mike Reed | 3404207 | 2017-08-08 16:29:22 -0400 | [diff] [blame] | 78 | if (!ctm.isScaleTranslate()) { |
| 79 | return true; |
| 80 | } |
Mike Reed | eefe9f9 | 2017-08-21 11:39:15 -0400 | [diff] [blame] | 81 | if (!localM.isScaleTranslate()) { |
| 82 | return true; |
| 83 | } |
Mike Reed | 980e279 | 2017-06-21 13:15:58 -0700 | [diff] [blame] | 84 | return false; |
| 85 | } |
| 86 | |
Mike Reed | 3404207 | 2017-08-08 16:29:22 -0400 | [diff] [blame] | 87 | bool SkImageShader::onIsRasterPipelineOnly(const SkMatrix& ctm) const { |
Mike Reed | 980e279 | 2017-06-21 13:15:58 -0700 | [diff] [blame] | 88 | SkBitmapProvider provider(fImage.get(), nullptr); |
Mike Reed | 3404207 | 2017-08-08 16:29:22 -0400 | [diff] [blame] | 89 | return IsRasterPipelineOnly(ctm, provider.info().colorType(), provider.info().alphaType(), |
Mike Reed | eefe9f9 | 2017-08-21 11:39:15 -0400 | [diff] [blame] | 90 | fTileModeX, fTileModeY, this->getLocalMatrix()); |
Mike Reed | 980e279 | 2017-06-21 13:15:58 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 93 | SkShaderBase::Context* SkImageShader::onMakeContext(const ContextRec& rec, |
| 94 | SkArenaAlloc* alloc) const { |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 95 | return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY, |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame] | 96 | SkBitmapProvider(fImage.get(), rec.fDstColorSpace), |
Herb Derby | 83e939b | 2017-02-07 14:25:11 -0500 | [diff] [blame] | 97 | rec, alloc); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 98 | } |
| 99 | |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 100 | SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const { |
| 101 | if (texM) { |
| 102 | *texM = this->getLocalMatrix(); |
| 103 | } |
| 104 | if (xy) { |
| 105 | xy[0] = (TileMode)fTileModeX; |
| 106 | xy[1] = (TileMode)fTileModeY; |
| 107 | } |
| 108 | return const_cast<SkImage*>(fImage.get()); |
| 109 | } |
| 110 | |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 111 | #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 112 | bool SkImageShader::onIsABitmap(SkBitmap* texture, SkMatrix* texM, TileMode xy[]) const { |
| 113 | const SkBitmap* bm = as_IB(fImage)->onPeekBitmap(); |
| 114 | if (!bm) { |
| 115 | return false; |
| 116 | } |
| 117 | |
| 118 | if (texture) { |
| 119 | *texture = *bm; |
| 120 | } |
| 121 | if (texM) { |
| 122 | *texM = this->getLocalMatrix(); |
| 123 | } |
| 124 | if (xy) { |
| 125 | xy[0] = (TileMode)fTileModeX; |
| 126 | xy[1] = (TileMode)fTileModeY; |
| 127 | } |
| 128 | return true; |
| 129 | } |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 130 | #endif |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 131 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 132 | static bool bitmap_is_too_big(int w, int h) { |
| 133 | // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it |
| 134 | // communicates between its matrix-proc and its sampler-proc. Until we can |
| 135 | // widen that, we have to reject bitmaps that are larger. |
| 136 | // |
| 137 | static const int kMaxSize = 65535; |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 138 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 139 | return w > kMaxSize || h > kMaxSize; |
| 140 | } |
| 141 | |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 142 | sk_sp<SkShader> SkImageShader::Make(sk_sp<SkImage> image, TileMode tx, TileMode ty, |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 143 | const SkMatrix* localMatrix) { |
Robert Phillips | 54be5c9 | 2017-02-11 01:19:30 +0000 | [diff] [blame] | 144 | if (!image || bitmap_is_too_big(image->width(), image->height())) { |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 145 | return sk_make_sp<SkEmptyShader>(); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 146 | } else { |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 147 | return sk_make_sp<SkImageShader>(image, tx, ty, localMatrix); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 148 | } |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | #ifndef SK_IGNORE_TO_STRING |
| 152 | void SkImageShader::toString(SkString* str) const { |
| 153 | const char* gTileModeName[SkShader::kTileModeCount] = { |
| 154 | "clamp", "repeat", "mirror" |
| 155 | }; |
| 156 | |
| 157 | str->appendf("ImageShader: ((%s %s) ", gTileModeName[fTileModeX], gTileModeName[fTileModeY]); |
| 158 | fImage->toString(str); |
| 159 | this->INHERITED::toString(str); |
| 160 | str->append(")"); |
| 161 | } |
| 162 | #endif |
| 163 | |
| 164 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 165 | |
| 166 | #if SK_SUPPORT_GPU |
| 167 | |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 168 | #include "GrColorSpaceInfo.h" |
Robert Phillips | 296b1cc | 2017-03-15 10:42:12 -0400 | [diff] [blame] | 169 | #include "GrContext.h" |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 170 | #include "SkGr.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 171 | #include "effects/GrBicubicEffect.h" |
| 172 | #include "effects/GrSimpleTextureEffect.h" |
| 173 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 174 | static GrSamplerState::WrapMode tile_mode_to_wrap_mode(const SkShader::TileMode tileMode) { |
| 175 | switch (tileMode) { |
| 176 | case SkShader::TileMode::kClamp_TileMode: |
| 177 | return GrSamplerState::WrapMode::kClamp; |
| 178 | case SkShader::TileMode::kRepeat_TileMode: |
| 179 | return GrSamplerState::WrapMode::kRepeat; |
| 180 | case SkShader::TileMode::kMirror_TileMode: |
| 181 | return GrSamplerState::WrapMode::kMirrorRepeat; |
| 182 | } |
| 183 | SK_ABORT("Unknown tile mode."); |
| 184 | return GrSamplerState::WrapMode::kClamp; |
| 185 | } |
| 186 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 187 | std::unique_ptr<GrFragmentProcessor> SkImageShader::asFragmentProcessor( |
| 188 | const AsFPArgs& args) const { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 189 | SkMatrix lmInverse; |
| 190 | if (!this->getLocalMatrix().invert(&lmInverse)) { |
| 191 | return nullptr; |
| 192 | } |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 193 | if (args.fLocalMatrix) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 194 | SkMatrix inv; |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 195 | if (!args.fLocalMatrix->invert(&inv)) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 196 | return nullptr; |
| 197 | } |
| 198 | lmInverse.postConcat(inv); |
| 199 | } |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 200 | |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 201 | GrSamplerState::WrapMode wrapModes[] = {tile_mode_to_wrap_mode(fTileModeX), |
| 202 | tile_mode_to_wrap_mode(fTileModeY)}; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 203 | |
| 204 | // Must set wrap and filter on the sampler before requesting a texture. In two places below |
| 205 | // we check the matrix scale factors to determine how to interpret the filter quality setting. |
| 206 | // This completely ignores the complexity of the drawVertices case where explicit local coords |
| 207 | // are provided by the caller. |
| 208 | bool doBicubic; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 209 | GrSamplerState::Filter textureFilterMode = GrSkFilterQualityToGrFilterMode( |
| 210 | args.fFilterQuality, *args.fViewMatrix, this->getLocalMatrix(), &doBicubic); |
| 211 | GrSamplerState samplerState(wrapModes, textureFilterMode); |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 212 | sk_sp<SkColorSpace> texColorSpace; |
Robert Phillips | 67c18d6 | 2017-01-20 12:44:06 -0500 | [diff] [blame] | 213 | SkScalar scaleAdjust[2] = { 1.0f, 1.0f }; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 214 | sk_sp<GrTextureProxy> proxy(as_IB(fImage)->asTextureProxyRef( |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 215 | args.fContext, samplerState, args.fDstColorSpaceInfo->colorSpace(), &texColorSpace, |
| 216 | scaleAdjust)); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 217 | if (!proxy) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 218 | return nullptr; |
| 219 | } |
| 220 | |
Brian Osman | f06ead9 | 2017-10-30 13:47:41 -0400 | [diff] [blame] | 221 | GrPixelConfig config = proxy->config(); |
| 222 | bool isAlphaOnly = GrPixelConfigIsAlphaOnly(config); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 223 | |
Robert Phillips | 67c18d6 | 2017-01-20 12:44:06 -0500 | [diff] [blame] | 224 | lmInverse.postScale(scaleAdjust[0], scaleAdjust[1]); |
| 225 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 226 | std::unique_ptr<GrFragmentProcessor> inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 227 | if (doBicubic) { |
Brian Osman | 5e34167 | 2017-10-18 10:23:18 -0400 | [diff] [blame] | 228 | inner = GrBicubicEffect::Make(std::move(proxy), lmInverse, wrapModes); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 229 | } else { |
Brian Osman | 2240be9 | 2017-10-18 13:15:13 -0400 | [diff] [blame] | 230 | inner = GrSimpleTextureEffect::Make(std::move(proxy), lmInverse, samplerState); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 231 | } |
Brian Osman | f06ead9 | 2017-10-30 13:47:41 -0400 | [diff] [blame] | 232 | inner = GrColorSpaceXformEffect::Make(std::move(inner), texColorSpace.get(), config, |
Brian Salomon | 4cbb6e6 | 2017-10-25 15:12:19 -0400 | [diff] [blame] | 233 | args.fDstColorSpaceInfo->colorSpace()); |
Robert Phillips | b726d58 | 2017-03-09 16:36:32 -0500 | [diff] [blame] | 234 | if (isAlphaOnly) { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 235 | return inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 236 | } |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 237 | return GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner)); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | #endif |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 241 | |
| 242 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 243 | #include "SkImagePriv.h" |
| 244 | |
| 245 | sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, |
| 246 | SkShader::TileMode tmy, const SkMatrix* localMatrix, |
Herb Derby | bfdc87a | 2017-02-14 15:06:23 +0000 | [diff] [blame] | 247 | SkCopyPixelsMode cpm) { |
| 248 | return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm), |
| 249 | tmx, tmy, localMatrix); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 252 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShaderBase) |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 253 | SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkImageShader) |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 254 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
| 255 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 256 | bool SkImageShader::onAppendStages(const StageRec& rec) const { |
| 257 | SkRasterPipeline* p = rec.fPipeline; |
| 258 | SkArenaAlloc* alloc = rec.fAlloc; |
| 259 | |
| 260 | auto matrix = SkMatrix::Concat(rec.fCTM, this->getLocalMatrix()); |
| 261 | if (rec.fLocalM) { |
| 262 | matrix.preConcat(*rec.fLocalM); |
Florin Malita | 882ccaf | 2017-01-27 10:51:58 -0500 | [diff] [blame] | 263 | } |
| 264 | |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 265 | if (!matrix.invert(&matrix)) { |
| 266 | return false; |
| 267 | } |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 268 | auto quality = rec.fPaint.getFilterQuality(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 269 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 270 | SkBitmapProvider provider(fImage.get(), rec.fDstCS); |
Mike Reed | e32500f | 2017-07-19 17:20:37 -0400 | [diff] [blame] | 271 | SkDefaultBitmapController controller; |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 272 | std::unique_ptr<SkBitmapController::State> state { |
| 273 | controller.requestBitmap(provider, matrix, quality) |
| 274 | }; |
| 275 | if (!state) { |
| 276 | return false; |
| 277 | } |
| 278 | |
| 279 | const SkPixmap& pm = state->pixmap(); |
| 280 | matrix = state->invMatrix(); |
| 281 | quality = state->quality(); |
| 282 | auto info = pm.info(); |
| 283 | |
Mike Klein | 7776029 | 2016-11-17 14:04:22 -0500 | [diff] [blame] | 284 | // When the matrix is just an integer translate, bilerp == nearest neighbor. |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 285 | if (quality == kLow_SkFilterQuality && |
| 286 | matrix.getType() <= SkMatrix::kTranslate_Mask && |
Mike Klein | 7776029 | 2016-11-17 14:04:22 -0500 | [diff] [blame] | 287 | matrix.getTranslateX() == (int)matrix.getTranslateX() && |
| 288 | matrix.getTranslateY() == (int)matrix.getTranslateY()) { |
| 289 | quality = kNone_SkFilterQuality; |
| 290 | } |
| 291 | |
Mike Klein | bf178a7 | 2016-11-17 15:56:24 -0500 | [diff] [blame] | 292 | // See skia:4649 and the GM image_scale_aligned. |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 293 | if (quality == kNone_SkFilterQuality) { |
| 294 | if (matrix.getScaleX() >= 0) { |
| 295 | matrix.setTranslateX(nextafterf(matrix.getTranslateX(), |
| 296 | floorf(matrix.getTranslateX()))); |
| 297 | } |
| 298 | if (matrix.getScaleY() >= 0) { |
| 299 | matrix.setTranslateY(nextafterf(matrix.getTranslateY(), |
| 300 | floorf(matrix.getTranslateY()))); |
| 301 | } |
| 302 | } |
| 303 | |
Mike Klein | 85f8536 | 2017-10-17 14:22:58 -0400 | [diff] [blame] | 304 | p->append_seed_shader(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 305 | |
| 306 | struct MiscCtx { |
| 307 | std::unique_ptr<SkBitmapController::State> state; |
| 308 | SkColor4f paint_color; |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 309 | }; |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 310 | auto misc = alloc->make<MiscCtx>(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 311 | misc->state = std::move(state); // Extend lifetime to match the pipeline's. |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 312 | misc->paint_color = SkColor4f_from_SkColor(rec.fPaint.getColor(), rec.fDstCS); |
Mike Reed | 6b59bf4 | 2017-07-03 21:26:44 -0400 | [diff] [blame] | 313 | p->append_matrix(alloc, matrix); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 314 | |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 315 | auto gather = alloc->make<SkJumper_GatherCtx>(); |
Mike Klein | 2bbcda3 | 2017-12-11 16:09:40 +0000 | [diff] [blame] | 316 | gather->pixels = pm.writable_addr(); // Don't worry, we won't write to it. |
Mike Klein | 968af43 | 2017-07-18 16:31:55 -0400 | [diff] [blame] | 317 | gather->stride = pm.rowBytesAsPixels(); |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 318 | gather->width = pm.width(); |
| 319 | gather->height = pm.height(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 320 | |
Mike Reed | 51e46d5 | 2017-06-23 14:21:25 -0400 | [diff] [blame] | 321 | auto limit_x = alloc->make<SkJumper_TileCtx>(), |
| 322 | limit_y = alloc->make<SkJumper_TileCtx>(); |
| 323 | limit_x->scale = pm.width(); |
| 324 | limit_x->invScale = 1.0f / pm.width(); |
| 325 | limit_y->scale = pm.height(); |
| 326 | limit_y->invScale = 1.0f / pm.height(); |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 327 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 328 | auto append_tiling_and_gather = [&] { |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 329 | switch (fTileModeX) { |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 330 | case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break; |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 331 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x, limit_x); break; |
| 332 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x, limit_x); break; |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 333 | } |
| 334 | switch (fTileModeY) { |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 335 | case kClamp_TileMode: /* The gather_xxx stage will clamp for us. */ break; |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 336 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_y, limit_y); break; |
| 337 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_y, limit_y); break; |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 338 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 339 | switch (info.colorType()) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 340 | case kAlpha_8_SkColorType: p->append(SkRasterPipeline::gather_a8, gather); break; |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 341 | case kGray_8_SkColorType: p->append(SkRasterPipeline::gather_g8, gather); break; |
| 342 | case kRGB_565_SkColorType: p->append(SkRasterPipeline::gather_565, gather); break; |
| 343 | case kARGB_4444_SkColorType: p->append(SkRasterPipeline::gather_4444, gather); break; |
Mike Klein | 111f8a9 | 2017-06-27 15:56:32 -0400 | [diff] [blame] | 344 | case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::gather_bgra, gather); break; |
| 345 | case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, gather); break; |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 346 | case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, gather); break; |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 347 | default: SkASSERT(false); |
| 348 | } |
Mike Klein | 2bbcda3 | 2017-12-11 16:09:40 +0000 | [diff] [blame] | 349 | if (rec.fDstCS && (!info.colorSpace() || info.gammaCloseToSRGB())) { |
Mike Klein | d37d5d9 | 2016-12-14 13:38:24 +0000 | [diff] [blame] | 350 | p->append_from_srgb(info.alphaType()); |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 351 | } |
| 352 | }; |
| 353 | |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 354 | SkJumper_SamplerCtx* sampler = nullptr; |
| 355 | if (quality != kNone_SkFilterQuality) { |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 356 | sampler = alloc->make<SkJumper_SamplerCtx>(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 357 | } |
| 358 | |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 359 | auto sample = [&](SkRasterPipeline::StockStage setup_x, |
| 360 | SkRasterPipeline::StockStage setup_y) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 361 | p->append(setup_x, sampler); |
| 362 | p->append(setup_y, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 363 | append_tiling_and_gather(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 364 | p->append(SkRasterPipeline::accumulate, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 365 | }; |
| 366 | |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 367 | if (quality == kNone_SkFilterQuality) { |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 368 | append_tiling_and_gather(); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 369 | } else if (quality == kLow_SkFilterQuality) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 370 | p->append(SkRasterPipeline::save_xy, sampler); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 371 | |
| 372 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_ny); |
| 373 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_ny); |
| 374 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_py); |
| 375 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_py); |
| 376 | |
| 377 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | 46e66a2 | 2016-11-21 16:19:34 -0500 | [diff] [blame] | 378 | } else { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 379 | p->append(SkRasterPipeline::save_xy, sampler); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 380 | |
| 381 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n3y); |
| 382 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n3y); |
| 383 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n3y); |
| 384 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n3y); |
| 385 | |
| 386 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n1y); |
| 387 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n1y); |
| 388 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n1y); |
| 389 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n1y); |
| 390 | |
| 391 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p1y); |
| 392 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p1y); |
| 393 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p1y); |
| 394 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p1y); |
| 395 | |
| 396 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p3y); |
| 397 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p3y); |
| 398 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p3y); |
| 399 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p3y); |
| 400 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 401 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 402 | } |
| 403 | |
Mike Klein | 2bbcda3 | 2017-12-11 16:09:40 +0000 | [diff] [blame] | 404 | if (info.colorType() == kAlpha_8_SkColorType) { |
| 405 | p->append(SkRasterPipeline::set_rgb, &misc->paint_color); |
| 406 | } |
| 407 | if (info.colorType() == kAlpha_8_SkColorType || info.alphaType() == kUnpremul_SkAlphaType) { |
| 408 | p->append(SkRasterPipeline::premul); |
| 409 | } |
| 410 | if (quality > kLow_SkFilterQuality) { |
| 411 | // Bicubic filtering naturally produces out of range values on both sides. |
| 412 | p->append(SkRasterPipeline::clamp_0); |
| 413 | p->append(SkRasterPipeline::clamp_a); |
| 414 | } |
| 415 | append_gamut_transform(p, alloc, info.colorSpace(), rec.fDstCS, kPremul_SkAlphaType); |
| 416 | return true; |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 417 | } |