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 | |
Brian Salomon | 0c24320 | 2020-06-29 14:29:25 -0400 | [diff] [blame] | 8 | #include "src/shaders/SkImageShader.h" |
| 9 | |
Ben Wagner | 729a23f | 2019-05-17 16:29:34 -0400 | [diff] [blame] | 10 | #include "src/core/SkArenaAlloc.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "src/core/SkColorSpacePriv.h" |
| 12 | #include "src/core/SkColorSpaceXformSteps.h" |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 13 | #include "src/core/SkMatrixPriv.h" |
Brian Osman | 449b115 | 2020-04-15 16:43:00 -0400 | [diff] [blame] | 14 | #include "src/core/SkMatrixProvider.h" |
Mike Reed | 60a2ec0 | 2020-12-08 09:18:14 -0500 | [diff] [blame] | 15 | #include "src/core/SkMipmapAccessor.h" |
Mike Klein | 37bc8f9 | 2019-10-21 13:10:07 -0500 | [diff] [blame] | 16 | #include "src/core/SkOpts.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 17 | #include "src/core/SkRasterPipeline.h" |
| 18 | #include "src/core/SkReadBuffer.h" |
Mike Reed | 9223665 | 2021-02-01 13:07:32 -0500 | [diff] [blame] | 19 | #include "src/core/SkSamplingPriv.h" |
Brian Salomon | 0c24320 | 2020-06-29 14:29:25 -0400 | [diff] [blame] | 20 | #include "src/core/SkScopeExit.h" |
Mike Klein | 8e71744 | 2020-01-07 10:22:33 -0600 | [diff] [blame] | 21 | #include "src/core/SkVM.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 22 | #include "src/core/SkWriteBuffer.h" |
| 23 | #include "src/image/SkImage_Base.h" |
| 24 | #include "src/shaders/SkBitmapProcShader.h" |
| 25 | #include "src/shaders/SkEmptyShader.h" |
Herb Derby | 5992f9e | 2021-07-17 18:19:03 -0400 | [diff] [blame] | 26 | #include "src/shaders/SkTransformShader.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 27 | |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 28 | SkM44 SkImageShader::CubicResamplerMatrix(float B, float C) { |
Mike Reed | 3867c70 | 2020-09-01 13:28:10 -0400 | [diff] [blame] | 29 | #if 0 |
| 30 | constexpr SkM44 kMitchell = SkM44( 1.f/18.f, -9.f/18.f, 15.f/18.f, -7.f/18.f, |
| 31 | 16.f/18.f, 0.f/18.f, -36.f/18.f, 21.f/18.f, |
| 32 | 1.f/18.f, 9.f/18.f, 27.f/18.f, -21.f/18.f, |
| 33 | 0.f/18.f, 0.f/18.f, -6.f/18.f, 7.f/18.f); |
| 34 | |
| 35 | constexpr SkM44 kCatmull = SkM44(0.0f, -0.5f, 1.0f, -0.5f, |
| 36 | 1.0f, 0.0f, -2.5f, 1.5f, |
| 37 | 0.0f, 0.5f, 2.0f, -1.5f, |
| 38 | 0.0f, 0.0f, -0.5f, 0.5f); |
| 39 | |
| 40 | if (B == 1.0f/3 && C == 1.0f/3) { |
| 41 | return kMitchell; |
| 42 | } |
| 43 | if (B == 0 && C == 0.5f) { |
| 44 | return kCatmull; |
| 45 | } |
| 46 | #endif |
| 47 | return SkM44( (1.f/6)*B, -(3.f/6)*B - C, (3.f/6)*B + 2*C, - (1.f/6)*B - C, |
| 48 | 1 - (2.f/6)*B, 0, -3 + (12.f/6)*B + C, 2 - (9.f/6)*B - C, |
| 49 | (1.f/6)*B, (3.f/6)*B + C, 3 - (15.f/6)*B - 2*C, -2 + (9.f/6)*B + C, |
| 50 | 0, 0, -C, (1.f/6)*B + C); |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 51 | } |
| 52 | |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 53 | /** |
| 54 | * We are faster in clamp, so always use that tiling when we can. |
| 55 | */ |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 56 | static SkTileMode optimize(SkTileMode tm, int dimension) { |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 57 | SkASSERT(dimension > 0); |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 58 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 59 | // need to update frameworks/base/libs/hwui/tests/unit/SkiaBehaviorTests.cpp:55 to allow |
| 60 | // for transforming to clamp. |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 61 | return tm; |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 62 | #else |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 63 | return dimension == 1 ? SkTileMode::kClamp : tm; |
Mike Reed | 2e3c955 | 2017-06-23 21:33:58 -0400 | [diff] [blame] | 64 | #endif |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 65 | } |
| 66 | |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 67 | SkImageShader::SkImageShader(sk_sp<SkImage> img, |
Mike Reed | e25b447 | 2019-04-02 17:49:12 -0400 | [diff] [blame] | 68 | SkTileMode tmx, SkTileMode tmy, |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 69 | const SkSamplingOptions& sampling, |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 70 | const SkMatrix* localMatrix, |
| 71 | bool clampAsIfUnpremul) |
| 72 | : INHERITED(localMatrix) |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 73 | , fImage(std::move(img)) |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 74 | , fSampling(sampling) |
Mike Reed | 587d082 | 2017-06-23 16:49:12 -0400 | [diff] [blame] | 75 | , fTileModeX(optimize(tmx, fImage->width())) |
| 76 | , fTileModeY(optimize(tmy, fImage->height())) |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 77 | , fClampAsIfUnpremul(clampAsIfUnpremul) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 78 | {} |
| 79 | |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 80 | // just used for legacy-unflattening |
| 81 | enum class LegacyFilterEnum { |
| 82 | kNone, |
| 83 | kLow, |
| 84 | kMedium, |
| 85 | kHigh, |
| 86 | // this is the special value for backward compatibility |
| 87 | kInheritFromPaint, |
| 88 | // this signals we should use the new SkFilterOptions |
| 89 | kUseFilterOptions, |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 90 | // use cubic and ignore FilterOptions |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 91 | kUseCubicResampler, |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 92 | |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 93 | kLast = kUseCubicResampler, |
| 94 | }; |
| 95 | |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 96 | // fClampAsIfUnpremul is always false when constructed through public APIs, |
| 97 | // so there's no need to read or write it here. |
| 98 | |
| 99 | sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 100 | auto tmx = buffer.read32LE<SkTileMode>(SkTileMode::kLastTileMode); |
| 101 | auto tmy = buffer.read32LE<SkTileMode>(SkTileMode::kLastTileMode); |
| 102 | |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 103 | SkSamplingOptions sampling; |
| 104 | bool readSampling = true; |
| 105 | if (buffer.isVersionLT(SkPicturePriv::kNoFilterQualityShaders_Version) && |
| 106 | !buffer.readBool() /* legacy has_sampling */) |
| 107 | { |
| 108 | readSampling = false; |
| 109 | // we just default to Nearest in sampling |
| 110 | } |
| 111 | if (readSampling) { |
Mike Reed | 9223665 | 2021-02-01 13:07:32 -0500 | [diff] [blame] | 112 | sampling = SkSamplingPriv::Read(buffer); |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | SkMatrix localMatrix; |
| 116 | buffer.readMatrix(&localMatrix); |
| 117 | sk_sp<SkImage> img = buffer.readImage(); |
| 118 | if (!img) { |
| 119 | return nullptr; |
| 120 | } |
| 121 | |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 122 | return SkImageShader::Make(std::move(img), tmx, tmy, sampling, &localMatrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | void SkImageShader::flatten(SkWriteBuffer& buffer) const { |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 126 | buffer.writeUInt((unsigned)fTileModeX); |
| 127 | buffer.writeUInt((unsigned)fTileModeY); |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 128 | |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 129 | SkSamplingPriv::Write(buffer, fSampling); |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 130 | |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 131 | buffer.writeMatrix(this->getLocalMatrix()); |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 132 | buffer.writeImage(fImage.get()); |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 133 | SkASSERT(fClampAsIfUnpremul == false); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | bool SkImageShader::isOpaque() const { |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 137 | return fImage->isOpaque() && |
| 138 | fTileModeX != SkTileMode::kDecal && fTileModeY != SkTileMode::kDecal; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 141 | constexpr SkCubicResampler kDefaultCubicResampler{1.0f/3, 1.0f/3}; |
| 142 | |
| 143 | static bool is_default_cubic_resampler(SkCubicResampler cubic) { |
| 144 | return SkScalarNearlyEqual(cubic.B, kDefaultCubicResampler.B) && |
| 145 | SkScalarNearlyEqual(cubic.C, kDefaultCubicResampler.C); |
| 146 | } |
| 147 | |
Mike Reed | 604e4c2 | 2020-11-25 21:08:17 -0500 | [diff] [blame] | 148 | #ifdef SK_ENABLE_LEGACY_SHADERCONTEXT |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 149 | |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 150 | static bool legacy_shader_can_handle(const SkMatrix& inv) { |
Mike Reed | 8106311 | 2020-06-09 17:36:33 -0400 | [diff] [blame] | 151 | SkASSERT(!inv.hasPerspective()); |
Mike Klein | 37bc8f9 | 2019-10-21 13:10:07 -0500 | [diff] [blame] | 152 | |
| 153 | // Scale+translate methods are always present, but affine might not be. |
| 154 | if (!SkOpts::S32_alpha_D32_filter_DXDY && !inv.isScaleTranslate()) { |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 155 | return false; |
| 156 | } |
| 157 | |
| 158 | // legacy code uses SkFixed 32.32, so ensure the inverse doesn't map device coordinates |
| 159 | // out of range. |
| 160 | const SkScalar max_dev_coord = 32767.0f; |
Mike Klein | 37bc8f9 | 2019-10-21 13:10:07 -0500 | [diff] [blame] | 161 | const SkRect src = inv.mapRect(SkRect::MakeWH(max_dev_coord, max_dev_coord)); |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 162 | |
Mike Reed | 1eb5ca4 | 2018-03-08 14:20:52 -0500 | [diff] [blame] | 163 | // take 1/4 of max signed 32bits so we have room to subtract local values |
Kevin Lubick | f76da63 | 2020-01-28 10:39:56 -0500 | [diff] [blame] | 164 | const SkScalar max_fixed32dot32 = float(SK_MaxS32) * 0.25f; |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 165 | if (!SkRect::MakeLTRB(-max_fixed32dot32, -max_fixed32dot32, |
Mike Klein | 37bc8f9 | 2019-10-21 13:10:07 -0500 | [diff] [blame] | 166 | +max_fixed32dot32, +max_fixed32dot32).contains(src)) { |
Mike Reed | a12c419 | 2018-02-01 16:34:03 -0500 | [diff] [blame] | 167 | return false; |
| 168 | } |
| 169 | |
| 170 | // legacy shader impl should be able to handle these matrices |
| 171 | return true; |
| 172 | } |
| 173 | |
Florin Malita | 4aed138 | 2017-05-25 10:38:07 -0400 | [diff] [blame] | 174 | SkShaderBase::Context* SkImageShader::onMakeContext(const ContextRec& rec, |
| 175 | SkArenaAlloc* alloc) const { |
Brian Osman | 0e18937 | 2018-10-19 11:58:29 -0400 | [diff] [blame] | 176 | if (fImage->alphaType() == kUnpremul_SkAlphaType) { |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 177 | return nullptr; |
| 178 | } |
Brian Osman | b70fd91 | 2018-10-22 16:10:44 -0400 | [diff] [blame] | 179 | if (fImage->colorType() != kN32_SkColorType) { |
| 180 | return nullptr; |
| 181 | } |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 182 | if (fTileModeX != fTileModeY) { |
| 183 | return nullptr; |
| 184 | } |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 185 | if (fTileModeX == SkTileMode::kDecal || fTileModeY == SkTileMode::kDecal) { |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 186 | return nullptr; |
| 187 | } |
| 188 | |
Mike Reed | bc4d88a | 2021-01-21 12:49:36 -0500 | [diff] [blame] | 189 | auto supported = [](const SkSamplingOptions& sampling) { |
| 190 | const std::tuple<SkFilterMode,SkMipmapMode> supported[] = { |
Mike Reed | 7cee3ef | 2021-03-19 16:00:52 -0400 | [diff] [blame] | 191 | {SkFilterMode::kNearest, SkMipmapMode::kNone}, // legacy None |
| 192 | {SkFilterMode::kLinear, SkMipmapMode::kNone}, // legacy Low |
| 193 | {SkFilterMode::kLinear, SkMipmapMode::kNearest}, // legacy Medium |
Mike Reed | bc4d88a | 2021-01-21 12:49:36 -0500 | [diff] [blame] | 194 | }; |
| 195 | for (auto [f, m] : supported) { |
| 196 | if (sampling.filter == f && sampling.mipmap == m) { |
| 197 | return true; |
| 198 | } |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 199 | } |
Mike Reed | bc4d88a | 2021-01-21 12:49:36 -0500 | [diff] [blame] | 200 | return false; |
| 201 | }; |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 202 | if (fSampling.useCubic || !supported(fSampling)) { |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 203 | return nullptr; |
| 204 | } |
| 205 | |
Mike Klein | dac694d | 2018-12-18 10:13:52 -0500 | [diff] [blame] | 206 | // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, |
Mike Klein | 67761eb | 2018-12-18 10:16:53 -0500 | [diff] [blame] | 207 | // so it can't handle bitmaps larger than 65535. |
Mike Klein | dac694d | 2018-12-18 10:13:52 -0500 | [diff] [blame] | 208 | // |
Mike Klein | 67761eb | 2018-12-18 10:16:53 -0500 | [diff] [blame] | 209 | // We back off another bit to 32767 to make small amounts of |
| 210 | // intermediate math safe, e.g. in |
| 211 | // |
| 212 | // SkFixed fx = ...; |
| 213 | // fx = tile(fx + SK_Fixed1); |
| 214 | // |
| 215 | // we want to make sure (fx + SK_Fixed1) never overflows. |
| 216 | if (fImage-> width() > 32767 || |
| 217 | fImage->height() > 32767) { |
Mike Klein | dac694d | 2018-12-18 10:13:52 -0500 | [diff] [blame] | 218 | return nullptr; |
| 219 | } |
| 220 | |
Florin Malita | af2769d | 2018-04-04 13:46:35 -0400 | [diff] [blame] | 221 | SkMatrix inv; |
| 222 | if (!this->computeTotalInverse(*rec.fMatrix, rec.fLocalMatrix, &inv) || |
| 223 | !legacy_shader_can_handle(inv)) { |
| 224 | return nullptr; |
| 225 | } |
| 226 | |
Mike Reed | 011d166 | 2019-02-28 17:19:25 -0500 | [diff] [blame] | 227 | if (!rec.isLegacyCompatible(fImage->colorSpace())) { |
| 228 | return nullptr; |
| 229 | } |
| 230 | |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 231 | return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY, fSampling, |
| 232 | as_IB(fImage.get()), rec, alloc); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 233 | } |
Mike Reed | e92aae6 | 2018-10-17 10:21:51 -0400 | [diff] [blame] | 234 | #endif |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 235 | |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 236 | SkImage* SkImageShader::onIsAImage(SkMatrix* texM, SkTileMode xy[]) const { |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 237 | if (texM) { |
| 238 | *texM = this->getLocalMatrix(); |
| 239 | } |
| 240 | if (xy) { |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 241 | xy[0] = fTileModeX; |
| 242 | xy[1] = fTileModeY; |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 243 | } |
| 244 | return const_cast<SkImage*>(fImage.get()); |
| 245 | } |
| 246 | |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 247 | sk_sp<SkShader> SkImageShader::Make(sk_sp<SkImage> image, |
Mike Reed | e25b447 | 2019-04-02 17:49:12 -0400 | [diff] [blame] | 248 | SkTileMode tmx, SkTileMode tmy, |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 249 | const SkSamplingOptions& options, |
Mike Klein | 1f31309 | 2018-01-03 10:30:21 -0500 | [diff] [blame] | 250 | const SkMatrix* localMatrix, |
| 251 | bool clampAsIfUnpremul) { |
Mike Reed | 15b95d6 | 2020-11-06 09:50:47 -0500 | [diff] [blame] | 252 | auto is_unit = [](float x) { |
| 253 | return x >= 0 && x <= 1; |
| 254 | }; |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 255 | if (options.useCubic) { |
| 256 | if (!is_unit(options.cubic.B) || !is_unit(options.cubic.C)) { |
Mike Reed | 15b95d6 | 2020-11-06 09:50:47 -0500 | [diff] [blame] | 257 | return nullptr; |
| 258 | } |
| 259 | } |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 260 | if (!image) { |
| 261 | return sk_make_sp<SkEmptyShader>(); |
| 262 | } |
| 263 | return sk_sp<SkShader>{ |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 264 | new SkImageShader(image, tmx, tmy, options, localMatrix, clampAsIfUnpremul) |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 265 | }; |
| 266 | } |
| 267 | |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 268 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 269 | |
| 270 | #if SK_SUPPORT_GPU |
| 271 | |
Brian Salomon | 4bc0c1f | 2019-09-30 15:12:27 -0400 | [diff] [blame] | 272 | #include "src/gpu/GrColorInfo.h" |
John Stiles | f743d4e | 2020-07-23 11:35:08 -0400 | [diff] [blame] | 273 | #include "src/gpu/effects/GrBlendFragmentProcessor.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 274 | |
Brian Salomon | aff329b | 2017-08-11 09:40:37 -0400 | [diff] [blame] | 275 | std::unique_ptr<GrFragmentProcessor> SkImageShader::asFragmentProcessor( |
Mike Reed | e3429e6 | 2018-01-19 11:43:34 -0500 | [diff] [blame] | 276 | const GrFPArgs& args) const { |
Florin Malita | 52f0291 | 2020-03-09 16:33:17 -0400 | [diff] [blame] | 277 | const auto lm = this->totalLocalMatrix(args.fPreLocalMatrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 278 | SkMatrix lmInverse; |
Florin Malita | c6c5ead | 2018-04-11 15:33:40 -0400 | [diff] [blame] | 279 | if (!lm->invert(&lmInverse)) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 280 | return nullptr; |
| 281 | } |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 282 | |
Brian Salomon | 6ef10e9 | 2021-04-20 09:11:24 -0400 | [diff] [blame] | 283 | SkTileMode tileModes[2] = {fTileModeX, fTileModeY}; |
| 284 | auto fp = as_IB(fImage.get())->asFragmentProcessor(args.fContext, |
| 285 | fSampling, |
| 286 | tileModes, |
| 287 | lmInverse); |
| 288 | if (!fp) { |
| 289 | return nullptr; |
Brian Salomon | f735351 | 2020-07-22 19:26:48 -0400 | [diff] [blame] | 290 | } |
Brian Salomon | 490f192 | 2021-02-01 13:14:37 -0500 | [diff] [blame] | 291 | |
Brian Salomon | 490f192 | 2021-02-01 13:14:37 -0500 | [diff] [blame] | 292 | fp = GrColorSpaceXformEffect::Make(std::move(fp), |
| 293 | fImage->colorSpace(), |
| 294 | fImage->alphaType(), |
| 295 | args.fDstColorInfo->colorSpace(), |
| 296 | kPremul_SkAlphaType); |
Brian Salomon | b43d699 | 2021-01-05 14:37:40 -0500 | [diff] [blame] | 297 | if (fImage->isAlphaOnly()) { |
Brian Salomon | 4b6e2f0 | 2021-07-08 14:04:21 -0400 | [diff] [blame] | 298 | return GrBlendFragmentProcessor::Make(std::move(fp), nullptr, SkBlendMode::kDstIn); |
Brian Salomon | c0d79e5 | 2019-04-10 15:02:11 -0400 | [diff] [blame] | 299 | } else if (args.fInputColorIsOpaque) { |
Brian Osman | 55cbc75 | 2021-05-27 11:57:13 -0400 | [diff] [blame] | 300 | // If the input alpha is known to be 1, we don't need to take the kSrcIn path. This is |
| 301 | // just an optimization. However, we can't just return 'fp' here. We need to actually |
| 302 | // inhibit the coverage-as-alpha optimization, or we'll fail to incorporate AA correctly. |
| 303 | // The OverrideInput FP happens to do that, so wrap our fp in one of those. The texture FP |
| 304 | // doesn't actually use the input color at all, so the overridden input is irrelevant. |
Brian Salomon | 0c24320 | 2020-06-29 14:29:25 -0400 | [diff] [blame] | 305 | return GrFragmentProcessor::OverrideInput(std::move(fp), SK_PMColor4fWHITE, false); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 306 | } |
Brian Salomon | 4b6e2f0 | 2021-07-08 14:04:21 -0400 | [diff] [blame] | 307 | return GrBlendFragmentProcessor::Make(std::move(fp), nullptr, SkBlendMode::kSrcIn); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 308 | } |
| 309 | |
| 310 | #endif |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 311 | |
| 312 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 313 | #include "src/core/SkImagePriv.h" |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 314 | |
Michael Ludwig | c47e81b | 2019-04-02 15:18:02 -0400 | [diff] [blame] | 315 | sk_sp<SkShader> SkMakeBitmapShaderForPaint(const SkPaint& paint, const SkBitmap& src, |
Mike Reed | e25b447 | 2019-04-02 17:49:12 -0400 | [diff] [blame] | 316 | SkTileMode tmx, SkTileMode tmy, |
Mike Reed | 172ba9e | 2020-12-17 15:57:55 -0500 | [diff] [blame] | 317 | const SkSamplingOptions& sampling, |
Michael Ludwig | c47e81b | 2019-04-02 15:18:02 -0400 | [diff] [blame] | 318 | const SkMatrix* localMatrix, SkCopyPixelsMode mode) { |
Mike Reed | 172ba9e | 2020-12-17 15:57:55 -0500 | [diff] [blame] | 319 | auto s = SkImageShader::Make(SkMakeImageFromRasterBitmap(src, mode), |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 320 | tmx, tmy, sampling, localMatrix); |
Michael Ludwig | c47e81b | 2019-04-02 15:18:02 -0400 | [diff] [blame] | 321 | if (!s) { |
| 322 | return nullptr; |
| 323 | } |
| 324 | if (src.colorType() == kAlpha_8_SkColorType && paint.getShader()) { |
| 325 | // Compose the image shader with the paint's shader. Alpha images+shaders should output the |
| 326 | // texture's alpha multiplied by the shader's color. DstIn (d*sa) will achieve this with |
| 327 | // the source image and dst shader (MakeBlend takes dst first, src second). |
Mike Reed | c8bea7d | 2019-04-09 13:55:36 -0400 | [diff] [blame] | 328 | s = SkShaders::Blend(SkBlendMode::kDstIn, paint.refShader(), std::move(s)); |
Michael Ludwig | c47e81b | 2019-04-02 15:18:02 -0400 | [diff] [blame] | 329 | } |
| 330 | return s; |
| 331 | } |
| 332 | |
Brian Salomon | 2335644 | 2018-11-30 15:33:19 -0500 | [diff] [blame] | 333 | void SkShaderBase::RegisterFlattenables() { SK_REGISTER_FLATTENABLE(SkImageShader); } |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 334 | |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 335 | class SkImageStageUpdater : public SkStageUpdater { |
| 336 | public: |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 337 | SkImageStageUpdater(const SkImageShader* shader, bool usePersp) |
Mike Reed | 0ae1b3d | 2020-03-04 17:47:43 -0500 | [diff] [blame] | 338 | : fShader(shader) |
| 339 | , fUsePersp(usePersp || as_SB(shader)->getLocalMatrix().hasPerspective()) |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 340 | {} |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 341 | |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 342 | const SkImageShader* fShader; |
| 343 | const bool fUsePersp; // else use affine |
| 344 | |
| 345 | // large enough for perspective, though often we just use 2x3 |
| 346 | float fMatrixStorage[9]; |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 347 | |
| 348 | #if 0 // TODO: when we support mipmaps |
| 349 | SkRasterPipeline_GatherCtx* fGather; |
| 350 | SkRasterPipeline_TileCtx* fLimitX; |
| 351 | SkRasterPipeline_TileCtx* fLimitY; |
| 352 | SkRasterPipeline_DecalTileCtx* fDecal; |
| 353 | #endif |
| 354 | |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 355 | void append_matrix_stage(SkRasterPipeline* p) { |
| 356 | if (fUsePersp) { |
| 357 | p->append(SkRasterPipeline::matrix_perspective, fMatrixStorage); |
| 358 | } else { |
| 359 | p->append(SkRasterPipeline::matrix_2x3, fMatrixStorage); |
| 360 | } |
| 361 | } |
| 362 | |
Brian Osman | d32ff90 | 2021-07-23 14:16:01 -0400 | [diff] [blame] | 363 | bool update(const SkMatrix& ctm) override { |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 364 | SkMatrix matrix; |
Brian Osman | d32ff90 | 2021-07-23 14:16:01 -0400 | [diff] [blame] | 365 | // TODO: We may have lost the original local matrix? |
| 366 | if (fShader->computeTotalInverse(ctm, nullptr, &matrix)) { |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 367 | if (fUsePersp) { |
| 368 | matrix.get9(fMatrixStorage); |
| 369 | } else { |
Mike Reed | 0ae1b3d | 2020-03-04 17:47:43 -0500 | [diff] [blame] | 370 | // if we get here, matrix should be affine. If it isn't, then defensively we |
| 371 | // won't draw (by returning false), but we should work to never let this |
| 372 | // happen (i.e. better preflight by the caller to know ahead of time that we |
| 373 | // may encounter perspective, either in the CTM, or in the localM). |
| 374 | // |
| 375 | // See https://bugs.chromium.org/p/skia/issues/detail?id=10004 |
| 376 | // |
| 377 | if (!matrix.asAffine(fMatrixStorage)) { |
| 378 | SkASSERT(false); |
| 379 | return false; |
| 380 | } |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 381 | } |
| 382 | return true; |
| 383 | } |
| 384 | return false; |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 385 | } |
| 386 | }; |
| 387 | |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 388 | static SkSamplingOptions tweak_sampling(SkSamplingOptions sampling, const SkMatrix& matrix) { |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 389 | SkFilterMode filter = sampling.filter; |
Mike Klein | dcc8960 | 2020-12-02 15:06:15 -0600 | [diff] [blame] | 390 | |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 391 | // When the matrix is just an integer translate, bilerp == nearest neighbor. |
Mike Klein | dcc8960 | 2020-12-02 15:06:15 -0600 | [diff] [blame] | 392 | if (filter == SkFilterMode::kLinear && |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 393 | matrix.getType() <= SkMatrix::kTranslate_Mask && |
| 394 | matrix.getTranslateX() == (int)matrix.getTranslateX() && |
| 395 | matrix.getTranslateY() == (int)matrix.getTranslateY()) { |
Mike Klein | dcc8960 | 2020-12-02 15:06:15 -0600 | [diff] [blame] | 396 | filter = SkFilterMode::kNearest; |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 397 | } |
| 398 | |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 399 | return SkSamplingOptions(filter, sampling.mipmap); |
| 400 | } |
| 401 | |
| 402 | static SkMatrix tweak_inv_matrix(SkFilterMode filter, SkMatrix matrix) { |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 403 | // See skia:4649 and the GM image_scale_aligned. |
Mike Klein | dcc8960 | 2020-12-02 15:06:15 -0600 | [diff] [blame] | 404 | if (filter == SkFilterMode::kNearest) { |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 405 | if (matrix.getScaleX() >= 0) { |
| 406 | matrix.setTranslateX(nextafterf(matrix.getTranslateX(), |
| 407 | floorf(matrix.getTranslateX()))); |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 408 | } |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 409 | if (matrix.getScaleY() >= 0) { |
| 410 | matrix.setTranslateY(nextafterf(matrix.getTranslateY(), |
| 411 | floorf(matrix.getTranslateY()))); |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 412 | } |
| 413 | } |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 414 | return matrix; |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 415 | } |
| 416 | |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 417 | bool SkImageShader::doStages(const SkStageRec& rec, SkImageStageUpdater* updater) const { |
Mike Reed | 39b4c86 | 2020-11-25 16:15:53 -0500 | [diff] [blame] | 418 | // We only support certain sampling options in stages so far |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 419 | auto sampling = fSampling; |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 420 | if (sampling.useCubic) { |
| 421 | if (!is_default_cubic_resampler(sampling.cubic)) { |
Mike Reed | 39b4c86 | 2020-11-25 16:15:53 -0500 | [diff] [blame] | 422 | return false; |
Mike Reed | 74c51ac | 2020-11-20 10:23:58 -0500 | [diff] [blame] | 423 | } |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 424 | } else if (sampling.mipmap == SkMipmapMode::kLinear) { |
Mike Reed | 39b4c86 | 2020-11-25 16:15:53 -0500 | [diff] [blame] | 425 | return false; |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 426 | } |
Mike Reed | 9290d01 | 2020-06-11 16:56:06 -0400 | [diff] [blame] | 427 | |
Mike Reed | 39b4c86 | 2020-11-25 16:15:53 -0500 | [diff] [blame] | 428 | |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 429 | if (updater && (sampling.mipmap != SkMipmapMode::kNone)) { |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 430 | // TODO: medium: recall RequestBitmap and update width/height accordingly |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 431 | return false; |
| 432 | } |
| 433 | |
Mike Reed | 1d8c42e | 2017-08-29 14:58:19 -0400 | [diff] [blame] | 434 | SkRasterPipeline* p = rec.fPipeline; |
| 435 | SkArenaAlloc* alloc = rec.fAlloc; |
| 436 | |
Florin Malita | 7558e4d | 2018-02-07 10:05:53 -0500 | [diff] [blame] | 437 | SkMatrix matrix; |
Brian Osman | 9aaec36 | 2020-05-08 14:54:37 -0400 | [diff] [blame] | 438 | if (!this->computeTotalInverse(rec.fMatrixProvider.localToDevice(), rec.fLocalM, &matrix)) { |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 439 | return false; |
| 440 | } |
Florin Malita | c7d6e0b | 2021-02-04 17:46:25 -0500 | [diff] [blame] | 441 | matrix.normalizePerspective(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 442 | |
Mike Reed | 6e73404 | 2021-02-12 15:30:19 -0500 | [diff] [blame] | 443 | SkASSERT(!sampling.useCubic || sampling.mipmap == SkMipmapMode::kNone); |
Mike Reed | bccdd90 | 2020-12-07 12:36:02 -0500 | [diff] [blame] | 444 | auto* access = SkMipmapAccessor::Make(alloc, fImage.get(), matrix, sampling.mipmap); |
| 445 | if (!access) { |
| 446 | return false; |
| 447 | } |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 448 | SkPixmap pm; |
| 449 | std::tie(pm, matrix) = access->level(); |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 450 | |
Mike Klein | e8de024 | 2018-03-10 12:37:11 -0500 | [diff] [blame] | 451 | p->append(SkRasterPipeline::seed_shader); |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 452 | |
| 453 | if (updater) { |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 454 | updater->append_matrix_stage(p); |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 455 | } else { |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 456 | if (!sampling.useCubic) { |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 457 | // TODO: can tweak_sampling sometimes for cubic too when B=0 |
| 458 | if (rec.fMatrixProvider.localToDeviceHitsPixelCenters()) { |
| 459 | sampling = tweak_sampling(sampling, matrix); |
| 460 | } |
| 461 | matrix = tweak_inv_matrix(sampling.filter, matrix); |
Mike Reed | 3d58d5a | 2020-11-23 13:32:36 -0500 | [diff] [blame] | 462 | } |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 463 | p->append_matrix(alloc, matrix); |
| 464 | } |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 465 | |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 466 | auto gather = alloc->make<SkRasterPipeline_GatherCtx>(); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 467 | gather->pixels = pm.addr(); |
Mike Klein | 968af43 | 2017-07-18 16:31:55 -0400 | [diff] [blame] | 468 | gather->stride = pm.rowBytesAsPixels(); |
Mike Klein | f3b4e16 | 2017-09-22 15:32:59 -0400 | [diff] [blame] | 469 | gather->width = pm.width(); |
| 470 | gather->height = pm.height(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 471 | |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 472 | auto limit_x = alloc->make<SkRasterPipeline_TileCtx>(), |
| 473 | limit_y = alloc->make<SkRasterPipeline_TileCtx>(); |
Mike Reed | 51e46d5 | 2017-06-23 14:21:25 -0400 | [diff] [blame] | 474 | limit_x->scale = pm.width(); |
| 475 | limit_x->invScale = 1.0f / pm.width(); |
| 476 | limit_y->scale = pm.height(); |
| 477 | limit_y->invScale = 1.0f / pm.height(); |
Mike Klein | fc84dc5 | 2017-05-11 15:29:31 -0400 | [diff] [blame] | 478 | |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 479 | SkRasterPipeline_DecalTileCtx* decal_ctx = nullptr; |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 480 | bool decal_x_and_y = fTileModeX == SkTileMode::kDecal && fTileModeY == SkTileMode::kDecal; |
| 481 | if (fTileModeX == SkTileMode::kDecal || fTileModeY == SkTileMode::kDecal) { |
Mike Klein | b11ab57 | 2018-10-24 06:42:14 -0400 | [diff] [blame] | 482 | decal_ctx = alloc->make<SkRasterPipeline_DecalTileCtx>(); |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 483 | decal_ctx->limit_x = limit_x->scale; |
| 484 | decal_ctx->limit_y = limit_y->scale; |
| 485 | } |
| 486 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 487 | auto append_tiling_and_gather = [&] { |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 488 | if (decal_x_and_y) { |
| 489 | p->append(SkRasterPipeline::decal_x_and_y, decal_ctx); |
| 490 | } else { |
| 491 | switch (fTileModeX) { |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 492 | case SkTileMode::kClamp: /* The gather_xxx stage will clamp for us. */ break; |
| 493 | case SkTileMode::kMirror: p->append(SkRasterPipeline::mirror_x, limit_x); break; |
| 494 | case SkTileMode::kRepeat: p->append(SkRasterPipeline::repeat_x, limit_x); break; |
| 495 | case SkTileMode::kDecal: p->append(SkRasterPipeline::decal_x, decal_ctx); break; |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 496 | } |
| 497 | switch (fTileModeY) { |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 498 | case SkTileMode::kClamp: /* The gather_xxx stage will clamp for us. */ break; |
| 499 | case SkTileMode::kMirror: p->append(SkRasterPipeline::mirror_y, limit_y); break; |
| 500 | case SkTileMode::kRepeat: p->append(SkRasterPipeline::repeat_y, limit_y); break; |
| 501 | case SkTileMode::kDecal: p->append(SkRasterPipeline::decal_y, decal_ctx); break; |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 502 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 503 | } |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 504 | |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 505 | void* ctx = gather; |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 506 | switch (pm.colorType()) { |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 507 | case kAlpha_8_SkColorType: p->append(SkRasterPipeline::gather_a8, ctx); break; |
Robert Phillips | ea1b30b | 2019-09-19 16:05:48 -0400 | [diff] [blame] | 508 | case kA16_unorm_SkColorType: p->append(SkRasterPipeline::gather_a16, ctx); break; |
| 509 | case kA16_float_SkColorType: p->append(SkRasterPipeline::gather_af16, ctx); break; |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 510 | case kRGB_565_SkColorType: p->append(SkRasterPipeline::gather_565, ctx); break; |
| 511 | case kARGB_4444_SkColorType: p->append(SkRasterPipeline::gather_4444, ctx); break; |
Robert Phillips | ea1b30b | 2019-09-19 16:05:48 -0400 | [diff] [blame] | 512 | case kR8G8_unorm_SkColorType: p->append(SkRasterPipeline::gather_rg88, ctx); break; |
| 513 | case kR16G16_unorm_SkColorType: p->append(SkRasterPipeline::gather_rg1616, ctx); break; |
| 514 | case kR16G16_float_SkColorType: p->append(SkRasterPipeline::gather_rgf16, ctx); break; |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 515 | case kRGBA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); break; |
| 516 | case kRGBA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); break; |
Robert Phillips | ea1b30b | 2019-09-19 16:05:48 -0400 | [diff] [blame] | 517 | case kR16G16B16A16_unorm_SkColorType: |
| 518 | p->append(SkRasterPipeline::gather_16161616,ctx); break; |
Mike Klein | b70990e | 2019-02-28 10:03:27 -0600 | [diff] [blame] | 519 | case kRGBA_F16Norm_SkColorType: |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 520 | case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, ctx); break; |
Mike Klein | 3785471 | 2018-06-26 11:43:06 -0400 | [diff] [blame] | 521 | case kRGBA_F32_SkColorType: p->append(SkRasterPipeline::gather_f32, ctx); break; |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 522 | |
Mike Klein | b1df5e5 | 2018-10-17 17:06:03 -0400 | [diff] [blame] | 523 | case kGray_8_SkColorType: p->append(SkRasterPipeline::gather_a8, ctx); |
| 524 | p->append(SkRasterPipeline::alpha_to_gray ); break; |
Mike Klein | 1a3eb52 | 2018-10-18 10:11:00 -0400 | [diff] [blame] | 525 | |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 526 | case kRGB_888x_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); |
| 527 | p->append(SkRasterPipeline::force_opaque ); break; |
Mike Klein | 1a3eb52 | 2018-10-18 10:11:00 -0400 | [diff] [blame] | 528 | |
Mike Klein | f7eb054 | 2020-02-11 12:19:08 -0600 | [diff] [blame] | 529 | case kBGRA_1010102_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); |
| 530 | p->append(SkRasterPipeline::swap_rb ); break; |
| 531 | |
Mike Klein | ac568a9 | 2018-01-25 09:09:32 -0500 | [diff] [blame] | 532 | case kRGB_101010x_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); |
| 533 | p->append(SkRasterPipeline::force_opaque ); break; |
| 534 | |
Mike Klein | f7eb054 | 2020-02-11 12:19:08 -0600 | [diff] [blame] | 535 | case kBGR_101010x_SkColorType: p->append(SkRasterPipeline::gather_1010102, ctx); |
| 536 | p->append(SkRasterPipeline::force_opaque ); |
| 537 | p->append(SkRasterPipeline::swap_rb ); break; |
| 538 | |
Mike Klein | 1a3eb52 | 2018-10-18 10:11:00 -0400 | [diff] [blame] | 539 | case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); |
| 540 | p->append(SkRasterPipeline::swap_rb ); break; |
| 541 | |
Mike Klein | b70990e | 2019-02-28 10:03:27 -0600 | [diff] [blame] | 542 | case kUnknown_SkColorType: SkASSERT(false); |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 543 | } |
Mike Reed | dfc0e91 | 2018-02-16 12:40:18 -0500 | [diff] [blame] | 544 | if (decal_ctx) { |
| 545 | p->append(SkRasterPipeline::check_decal_mask, decal_ctx); |
| 546 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 547 | }; |
| 548 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 549 | auto append_misc = [&] { |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 550 | SkColorSpace* cs = pm.colorSpace(); |
| 551 | SkAlphaType at = pm.alphaType(); |
Mike Klein | 6a9f1c4 | 2020-01-02 23:23:42 -0600 | [diff] [blame] | 552 | |
| 553 | // Color for A8 images comes from the paint. TODO: all alpha images? none? |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 554 | if (pm.colorType() == kAlpha_8_SkColorType) { |
Mike Klein | 6a9f1c4 | 2020-01-02 23:23:42 -0600 | [diff] [blame] | 555 | SkColor4f rgb = rec.fPaint.getColor4f(); |
| 556 | p->append_set_rgb(alloc, rgb); |
| 557 | |
Mike Klein | 6a9f1c4 | 2020-01-02 23:23:42 -0600 | [diff] [blame] | 558 | cs = sk_srgb_singleton(); |
| 559 | at = kUnpremul_SkAlphaType; |
| 560 | } |
| 561 | |
Mike Klein | 059e043 | 2020-01-02 16:32:38 -0600 | [diff] [blame] | 562 | // Bicubic filtering naturally produces out of range values on both sides of [0,1]. |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 563 | if (sampling.useCubic) { |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 564 | p->append(SkRasterPipeline::clamp_0); |
Mike Klein | 059e043 | 2020-01-02 16:32:38 -0600 | [diff] [blame] | 565 | p->append(at == kUnpremul_SkAlphaType || fClampAsIfUnpremul |
| 566 | ? SkRasterPipeline::clamp_1 |
| 567 | : SkRasterPipeline::clamp_a); |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 568 | } |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 569 | |
Mike Klein | 059e043 | 2020-01-02 16:32:38 -0600 | [diff] [blame] | 570 | // Transform color space and alpha type to match shader convention (dst CS, premul alpha). |
| 571 | alloc->make<SkColorSpaceXformSteps>(cs, at, |
| 572 | rec.fDstCS, kPremul_SkAlphaType) |
Mike Klein | ec8e0bf | 2020-05-22 11:42:38 -0500 | [diff] [blame] | 573 | ->apply(p); |
Mike Klein | b82edcc | 2018-07-10 18:25:03 +0000 | [diff] [blame] | 574 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 575 | return true; |
| 576 | }; |
| 577 | |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 578 | // Check for fast-path stages. |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 579 | auto ct = pm.colorType(); |
Mike Klein | 8e3426f | 2018-04-16 12:56:24 -0400 | [diff] [blame] | 580 | if (true |
| 581 | && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 582 | && !sampling.useCubic && sampling.filter == SkFilterMode::kLinear |
Mike Reed | fae8fce | 2019-04-03 10:27:45 -0400 | [diff] [blame] | 583 | && fTileModeX == SkTileMode::kClamp && fTileModeY == SkTileMode::kClamp) { |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 584 | |
| 585 | p->append(SkRasterPipeline::bilerp_clamp_8888, gather); |
Mike Klein | 8e3426f | 2018-04-16 12:56:24 -0400 | [diff] [blame] | 586 | if (ct == kBGRA_8888_SkColorType) { |
| 587 | p->append(SkRasterPipeline::swap_rb); |
| 588 | } |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 589 | return append_misc(); |
| 590 | } |
Mike Reed | 78eedba | 2019-07-31 16:39:15 -0400 | [diff] [blame] | 591 | if (true |
Mike Klein | 0100562 | 2019-08-13 12:22:17 -0400 | [diff] [blame] | 592 | && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) // TODO: all formats |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 593 | && !sampling.useCubic && sampling.filter == SkFilterMode::kLinear |
Mike Klein | 0100562 | 2019-08-13 12:22:17 -0400 | [diff] [blame] | 594 | && fTileModeX != SkTileMode::kDecal // TODO decal too? |
| 595 | && fTileModeY != SkTileMode::kDecal) { |
| 596 | |
| 597 | auto ctx = alloc->make<SkRasterPipeline_SamplerCtx2>(); |
| 598 | *(SkRasterPipeline_GatherCtx*)(ctx) = *gather; |
| 599 | ctx->ct = ct; |
| 600 | ctx->tileX = fTileModeX; |
| 601 | ctx->tileY = fTileModeY; |
| 602 | ctx->invWidth = 1.0f / ctx->width; |
| 603 | ctx->invHeight = 1.0f / ctx->height; |
| 604 | p->append(SkRasterPipeline::bilinear, ctx); |
| 605 | return append_misc(); |
| 606 | } |
| 607 | if (true |
Mike Reed | 78eedba | 2019-07-31 16:39:15 -0400 | [diff] [blame] | 608 | && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 609 | && sampling.useCubic |
Mike Reed | 78eedba | 2019-07-31 16:39:15 -0400 | [diff] [blame] | 610 | && fTileModeX == SkTileMode::kClamp && fTileModeY == SkTileMode::kClamp) { |
| 611 | |
| 612 | p->append(SkRasterPipeline::bicubic_clamp_8888, gather); |
| 613 | if (ct == kBGRA_8888_SkColorType) { |
| 614 | p->append(SkRasterPipeline::swap_rb); |
| 615 | } |
| 616 | return append_misc(); |
| 617 | } |
Mike Klein | 0100562 | 2019-08-13 12:22:17 -0400 | [diff] [blame] | 618 | if (true |
| 619 | && (ct == kRGBA_8888_SkColorType || ct == kBGRA_8888_SkColorType) // TODO: all formats |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 620 | && sampling.useCubic |
Mike Klein | 0100562 | 2019-08-13 12:22:17 -0400 | [diff] [blame] | 621 | && fTileModeX != SkTileMode::kDecal // TODO decal too? |
| 622 | && fTileModeY != SkTileMode::kDecal) { |
| 623 | |
| 624 | auto ctx = alloc->make<SkRasterPipeline_SamplerCtx2>(); |
| 625 | *(SkRasterPipeline_GatherCtx*)(ctx) = *gather; |
| 626 | ctx->ct = ct; |
| 627 | ctx->tileX = fTileModeX; |
| 628 | ctx->tileY = fTileModeY; |
| 629 | ctx->invWidth = 1.0f / ctx->width; |
| 630 | ctx->invHeight = 1.0f / ctx->height; |
| 631 | p->append(SkRasterPipeline::bicubic, ctx); |
| 632 | return append_misc(); |
| 633 | } |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 634 | |
Mike Reed | 3d58d5a | 2020-11-23 13:32:36 -0500 | [diff] [blame] | 635 | SkRasterPipeline_SamplerCtx* sampler = alloc->make<SkRasterPipeline_SamplerCtx>(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 636 | |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 637 | auto sample = [&](SkRasterPipeline::StockStage setup_x, |
| 638 | SkRasterPipeline::StockStage setup_y) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 639 | p->append(setup_x, sampler); |
| 640 | p->append(setup_y, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 641 | append_tiling_and_gather(); |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 642 | p->append(SkRasterPipeline::accumulate, sampler); |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 643 | }; |
| 644 | |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 645 | if (sampling.useCubic) { |
Mike Klein | 0a90449 | 2017-04-12 12:52:48 -0400 | [diff] [blame] | 646 | p->append(SkRasterPipeline::save_xy, sampler); |
Mike Klein | b0b17d1 | 2016-12-09 16:25:44 -0500 | [diff] [blame] | 647 | |
| 648 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n3y); |
| 649 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n3y); |
| 650 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n3y); |
| 651 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n3y); |
| 652 | |
| 653 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_n1y); |
| 654 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_n1y); |
| 655 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_n1y); |
| 656 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_n1y); |
| 657 | |
| 658 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p1y); |
| 659 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p1y); |
| 660 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p1y); |
| 661 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p1y); |
| 662 | |
| 663 | sample(SkRasterPipeline::bicubic_n3x, SkRasterPipeline::bicubic_p3y); |
| 664 | sample(SkRasterPipeline::bicubic_n1x, SkRasterPipeline::bicubic_p3y); |
| 665 | sample(SkRasterPipeline::bicubic_p1x, SkRasterPipeline::bicubic_p3y); |
| 666 | sample(SkRasterPipeline::bicubic_p3x, SkRasterPipeline::bicubic_p3y); |
| 667 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 668 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 669 | } else if (sampling.filter == SkFilterMode::kLinear) { |
Mike Reed | 3d58d5a | 2020-11-23 13:32:36 -0500 | [diff] [blame] | 670 | p->append(SkRasterPipeline::save_xy, sampler); |
| 671 | |
| 672 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_ny); |
| 673 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_ny); |
| 674 | sample(SkRasterPipeline::bilinear_nx, SkRasterPipeline::bilinear_py); |
| 675 | sample(SkRasterPipeline::bilinear_px, SkRasterPipeline::bilinear_py); |
| 676 | |
| 677 | p->append(SkRasterPipeline::move_dst_src); |
| 678 | } else { |
| 679 | append_tiling_and_gather(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 680 | } |
| 681 | |
Mike Klein | 1fa9c43 | 2017-12-11 09:59:47 -0500 | [diff] [blame] | 682 | return append_misc(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 683 | } |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 684 | |
| 685 | bool SkImageShader::onAppendStages(const SkStageRec& rec) const { |
| 686 | return this->doStages(rec, nullptr); |
| 687 | } |
| 688 | |
| 689 | SkStageUpdater* SkImageShader::onAppendUpdatableStages(const SkStageRec& rec) const { |
Brian Osman | 9aaec36 | 2020-05-08 14:54:37 -0400 | [diff] [blame] | 690 | bool usePersp = rec.fMatrixProvider.localToDevice().hasPerspective(); |
Mike Reed | 8845c37 | 2019-12-19 13:22:08 -0500 | [diff] [blame] | 691 | auto updater = rec.fAlloc->make<SkImageStageUpdater>(this, usePersp); |
Mike Reed | 9318a6c | 2019-08-16 16:16:25 -0400 | [diff] [blame] | 692 | return this->doStages(rec, updater) ? updater : nullptr; |
| 693 | } |
| 694 | |
Herb Derby | 5992f9e | 2021-07-17 18:19:03 -0400 | [diff] [blame] | 695 | class SkImageShader::TransformShader : public SkTransformShader { |
| 696 | public: |
| 697 | explicit TransformShader(const SkImageShader& shader) |
| 698 | : SkTransformShader{shader} |
| 699 | , fImageShader{shader} {} |
| 700 | |
| 701 | skvm::Color onProgram(skvm::Builder* b, |
| 702 | skvm::Coord device, skvm::Coord local, skvm::Color color, |
| 703 | const SkMatrixProvider& matrices, const SkMatrix* localM, |
| 704 | const SkColorInfo& dst, |
| 705 | skvm::Uniforms* uniforms, SkArenaAlloc* alloc) const override { |
| 706 | return fImageShader.makeProgram( |
| 707 | b, device, local, color, matrices, localM, dst, uniforms, this, alloc); |
| 708 | } |
| 709 | |
| 710 | private: |
| 711 | const SkImageShader& fImageShader; |
| 712 | }; |
| 713 | |
| 714 | SkUpdatableShader* SkImageShader::onUpdatableShader(SkArenaAlloc* alloc) const { |
| 715 | return alloc->make<TransformShader>(*this); |
| 716 | } |
| 717 | |
| 718 | skvm::Color SkImageShader::onProgram(skvm::Builder* b, |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 719 | skvm::Coord device, skvm::Coord origLocal, skvm::Color paint, |
Mike Klein | e81b108 | 2020-06-19 11:29:13 -0500 | [diff] [blame] | 720 | const SkMatrixProvider& matrices, const SkMatrix* localM, |
Mike Reed | 8046837 | 2021-03-19 14:05:19 -0400 | [diff] [blame] | 721 | const SkColorInfo& dst, |
Mike Klein | 276a785 | 2020-03-15 08:46:09 -0500 | [diff] [blame] | 722 | skvm::Uniforms* uniforms, SkArenaAlloc* alloc) const { |
Herb Derby | 5992f9e | 2021-07-17 18:19:03 -0400 | [diff] [blame] | 723 | return this->makeProgram( |
| 724 | b, device, origLocal, paint, matrices, localM, dst, uniforms, nullptr, alloc); |
| 725 | } |
| 726 | |
| 727 | skvm::Color SkImageShader::makeProgram( |
| 728 | skvm::Builder* p, skvm::Coord device, skvm::Coord origLocal, skvm::Color paint, |
| 729 | const SkMatrixProvider& matrices, const SkMatrix* localM, const SkColorInfo& dst, |
| 730 | skvm::Uniforms* uniforms, const TransformShader* coordShader, SkArenaAlloc* alloc) const { |
| 731 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 732 | SkMatrix baseInv; |
| 733 | if (!this->computeTotalInverse(matrices.localToDevice(), localM, &baseInv)) { |
Mike Reed | 6352f00 | 2020-03-14 23:30:10 -0400 | [diff] [blame] | 734 | return {}; |
Mike Klein | f6a715b | 2019-12-30 15:24:18 -0600 | [diff] [blame] | 735 | } |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 736 | baseInv.normalizePerspective(); |
Mike Klein | f6a715b | 2019-12-30 15:24:18 -0600 | [diff] [blame] | 737 | |
Mike Reed | 225cdea | 2021-03-18 22:19:44 -0400 | [diff] [blame] | 738 | auto sampling = fSampling; |
Mike Reed | bccdd90 | 2020-12-07 12:36:02 -0500 | [diff] [blame] | 739 | auto* access = SkMipmapAccessor::Make(alloc, fImage.get(), baseInv, sampling.mipmap); |
| 740 | if (!access) { |
| 741 | return {}; |
| 742 | } |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 743 | auto [upper, upperInv] = access->level(); |
Herb Derby | 98c2dd3 | 2021-07-29 17:48:54 -0400 | [diff] [blame] | 744 | // If we are using a coordShader, then we can't make guesses about the state of the matrix. |
| 745 | if (!sampling.useCubic && !coordShader) { |
Mike Klein | 71d420d | 2021-02-03 09:54:07 -0600 | [diff] [blame] | 746 | // TODO: can tweak_sampling sometimes for cubic too when B=0 |
| 747 | if (matrices.localToDeviceHitsPixelCenters()) { |
| 748 | sampling = tweak_sampling(sampling, upperInv); |
| 749 | } |
| 750 | upperInv = tweak_inv_matrix(sampling.filter, upperInv); |
Mike Klein | f6a715b | 2019-12-30 15:24:18 -0600 | [diff] [blame] | 751 | } |
Mike Klein | f6a715b | 2019-12-30 15:24:18 -0600 | [diff] [blame] | 752 | |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 753 | SkPixmap lowerPixmap; |
| 754 | SkMatrix lowerInv; |
| 755 | SkPixmap* lower = nullptr; |
| 756 | float lowerWeight = access->lowerWeight(); |
| 757 | if (lowerWeight > 0) { |
| 758 | std::tie(lowerPixmap, lowerInv) = access->lowerLevel(); |
| 759 | lower = &lowerPixmap; |
| 760 | } |
| 761 | |
Herb Derby | 5992f9e | 2021-07-17 18:19:03 -0400 | [diff] [blame] | 762 | skvm::Coord upperLocal; |
| 763 | if (coordShader != nullptr) { |
| 764 | upperLocal = coordShader->applyMatrix(p, upperInv, origLocal, uniforms); |
| 765 | } else { |
| 766 | upperLocal = SkShaderBase::ApplyMatrix(p, upperInv, origLocal, uniforms); |
| 767 | } |
Mike Klein | 6dbd7ff | 2020-01-06 11:50:37 -0600 | [diff] [blame] | 768 | |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 769 | // We can exploit image opacity to skip work unpacking alpha channels. |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 770 | const bool input_is_opaque = SkAlphaTypeIsOpaque(upper.alphaType()) |
| 771 | || SkColorTypeIsAlwaysOpaque(upper.colorType()); |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 772 | |
Mike Klein | 03d89ef | 2020-01-14 17:18:29 -0600 | [diff] [blame] | 773 | // Each call to sample() will try to rewrite the same uniforms over and over, |
| 774 | // so remember where we start and reset back there each time. That way each |
| 775 | // sample() call uses the same uniform offsets. |
Mike Klein | 03d89ef | 2020-01-14 17:18:29 -0600 | [diff] [blame] | 776 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 777 | auto compute_clamp_limit = [&](float limit) { |
| 778 | // Subtract an ulp so the upper clamp limit excludes limit itself. |
| 779 | int bits; |
| 780 | memcpy(&bits, &limit, 4); |
| 781 | return p->uniformF(uniforms->push(bits-1)); |
| 782 | }; |
Mike Klein | 03d89ef | 2020-01-14 17:18:29 -0600 | [diff] [blame] | 783 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 784 | // Except in the simplest case (no mips, no filtering), we reference uniforms |
| 785 | // more than once. To avoid adding/registering them multiple times, we pre-load them |
| 786 | // into a struct (just to logically group them together), based on the "current" |
| 787 | // pixmap (level of a mipmap). |
| 788 | // |
| 789 | struct Uniforms { |
| 790 | skvm::F32 w, iw, i2w, |
| 791 | h, ih, i2h; |
| 792 | |
| 793 | skvm::F32 clamp_w, |
| 794 | clamp_h; |
| 795 | |
| 796 | skvm::Uniform addr; |
| 797 | skvm::I32 rowBytesAsPixels; |
| 798 | |
Mike Klein | 03c932c | 2020-07-13 09:07:42 -0500 | [diff] [blame] | 799 | skvm::PixelFormat pixelFormat; // not a uniform, but needed for each texel sample, |
| 800 | // so we store it here, since it is also dependent on |
| 801 | // the current pixmap (level). |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 802 | }; |
| 803 | |
| 804 | auto setup_uniforms = [&](const SkPixmap& pm) -> Uniforms { |
Mike Klein | 447f331 | 2021-02-08 09:46:59 -0600 | [diff] [blame] | 805 | skvm::PixelFormat pixelFormat = skvm::SkColorType_to_PixelFormat(pm.colorType()); |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 806 | return { |
| 807 | p->uniformF(uniforms->pushF( pm.width())), |
| 808 | p->uniformF(uniforms->pushF(1.0f/pm.width())), // iff tileX == kRepeat |
| 809 | p->uniformF(uniforms->pushF(0.5f/pm.width())), // iff tileX == kMirror |
| 810 | |
| 811 | p->uniformF(uniforms->pushF( pm.height())), |
| 812 | p->uniformF(uniforms->pushF(1.0f/pm.height())), // iff tileY == kRepeat |
| 813 | p->uniformF(uniforms->pushF(0.5f/pm.height())), // iff tileY == kMirror |
| 814 | |
| 815 | compute_clamp_limit(pm. width()), |
| 816 | compute_clamp_limit(pm.height()), |
| 817 | |
| 818 | uniforms->pushPtr(pm.addr()), |
| 819 | p->uniform32(uniforms->push(pm.rowBytesAsPixels())), |
| 820 | |
Mike Klein | 03c932c | 2020-07-13 09:07:42 -0500 | [diff] [blame] | 821 | pixelFormat, |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 822 | }; |
| 823 | }; |
| 824 | |
| 825 | auto sample_texel = [&](const Uniforms& u, skvm::F32 sx, skvm::F32 sy) -> skvm::Color { |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 826 | // repeat() and mirror() are written assuming they'll be followed by a [0,scale) clamp. |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 827 | auto repeat = [&](skvm::F32 v, skvm::F32 S, skvm::F32 I) { |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 828 | return v - floor(v * I) * S; |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 829 | }; |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 830 | auto mirror = [&](skvm::F32 v, skvm::F32 S, skvm::F32 I2) { |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 831 | // abs( (v-scale) - (2*scale)*floor((v-scale)*(0.5f/scale)) - scale ) |
| 832 | // {---A---} {------------------B------------------} |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 833 | skvm::F32 A = v - S, |
| 834 | B = (S + S) * floor(A * I2); |
| 835 | return abs(A - B - S); |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 836 | }; |
| 837 | switch (fTileModeX) { |
| 838 | case SkTileMode::kDecal: /* handled after gather */ break; |
| 839 | case SkTileMode::kClamp: /* we always clamp */ break; |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 840 | case SkTileMode::kRepeat: sx = repeat(sx, u.w, u.iw); break; |
| 841 | case SkTileMode::kMirror: sx = mirror(sx, u.w, u.i2w); break; |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 842 | } |
| 843 | switch (fTileModeY) { |
| 844 | case SkTileMode::kDecal: /* handled after gather */ break; |
| 845 | case SkTileMode::kClamp: /* we always clamp */ break; |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 846 | case SkTileMode::kRepeat: sy = repeat(sy, u.h, u.ih); break; |
| 847 | case SkTileMode::kMirror: sy = mirror(sy, u.h, u.i2h); break; |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 848 | } |
| 849 | |
| 850 | // Always clamp sample coordinates to [0,width), [0,height), both for memory |
| 851 | // safety and to handle the clamps still needed by kClamp, kRepeat, and kMirror. |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 852 | skvm::F32 clamped_x = clamp(sx, 0, u.clamp_w), |
| 853 | clamped_y = clamp(sy, 0, u.clamp_h); |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 854 | |
| 855 | // Load pixels from pm.addr()[(int)sx + (int)sy*stride]. |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 856 | skvm::I32 index = trunc(clamped_x) + |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 857 | trunc(clamped_y) * u.rowBytesAsPixels; |
Mike Klein | 03c932c | 2020-07-13 09:07:42 -0500 | [diff] [blame] | 858 | skvm::Color c = gather(u.pixelFormat, u.addr, index); |
Mike Klein | 913a6f5 | 2020-03-23 11:06:25 -0500 | [diff] [blame] | 859 | |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 860 | // If we know the image is opaque, jump right to alpha = 1.0f, skipping work to unpack it. |
| 861 | if (input_is_opaque) { |
Mike Klein | 46874ef | 2020-02-13 10:17:08 -0600 | [diff] [blame] | 862 | c.a = p->splat(1.0f); |
| 863 | } |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 864 | |
| 865 | // Mask away any pixels that we tried to sample outside the bounds in kDecal. |
| 866 | if (fTileModeX == SkTileMode::kDecal || fTileModeY == SkTileMode::kDecal) { |
| 867 | skvm::I32 mask = p->splat(~0); |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 868 | if (fTileModeX == SkTileMode::kDecal) { mask &= (sx == clamped_x); } |
| 869 | if (fTileModeY == SkTileMode::kDecal) { mask &= (sy == clamped_y); } |
Mike Klein | 5ec9c4e | 2020-12-01 10:43:46 -0600 | [diff] [blame] | 870 | c.r = pun_to_F32(p->bit_and(mask, pun_to_I32(c.r))); |
| 871 | c.g = pun_to_F32(p->bit_and(mask, pun_to_I32(c.g))); |
| 872 | c.b = pun_to_F32(p->bit_and(mask, pun_to_I32(c.b))); |
| 873 | c.a = pun_to_F32(p->bit_and(mask, pun_to_I32(c.a))); |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 874 | // Notice that even if input_is_opaque, c.a might now be 0. |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 875 | } |
| 876 | |
| 877 | return c; |
| 878 | }; |
| 879 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 880 | auto sample_level = [&](const SkPixmap& pm, const SkMatrix& inv, skvm::Coord local) { |
| 881 | const Uniforms u = setup_uniforms(pm); |
Mike Reed | 6352f00 | 2020-03-14 23:30:10 -0400 | [diff] [blame] | 882 | |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 883 | if (sampling.useCubic) { |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 884 | // All bicubic samples have the same fractional offset (fx,fy) from the center. |
| 885 | // They're either the 16 corners of a 3x3 grid/ surrounding (x,y) at (0.5,0.5) off-center. |
| 886 | skvm::F32 fx = fract(local.x + 0.5f), |
| 887 | fy = fract(local.y + 0.5f); |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 888 | skvm::F32 wx[4], |
| 889 | wy[4]; |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 890 | |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 891 | SkM44 weights = CubicResamplerMatrix(sampling.cubic.B, sampling.cubic.C); |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 892 | |
Mike Klein | d318489 | 2020-07-22 17:39:20 -0500 | [diff] [blame] | 893 | auto dot = [](const skvm::F32 a[], const skvm::F32 b[]) { |
| 894 | return a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]; |
| 895 | }; |
| 896 | const skvm::F32 tmpx[] = { p->splat(1.0f), fx, fx*fx, fx*fx*fx }; |
| 897 | const skvm::F32 tmpy[] = { p->splat(1.0f), fy, fy*fy, fy*fy*fy }; |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 898 | |
Mike Klein | d318489 | 2020-07-22 17:39:20 -0500 | [diff] [blame] | 899 | for (int row = 0; row < 4; ++row) { |
| 900 | SkV4 r = weights.row(row); |
| 901 | skvm::F32 ru[] = { |
| 902 | p->uniformF(uniforms->pushF(r[0])), |
| 903 | p->uniformF(uniforms->pushF(r[1])), |
| 904 | p->uniformF(uniforms->pushF(r[2])), |
| 905 | p->uniformF(uniforms->pushF(r[3])), |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 906 | }; |
Mike Klein | d318489 | 2020-07-22 17:39:20 -0500 | [diff] [blame] | 907 | wx[row] = dot(ru, tmpx); |
| 908 | wy[row] = dot(ru, tmpy); |
Mike Reed | 3d30ca6 | 2020-07-22 16:55:02 -0400 | [diff] [blame] | 909 | } |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 910 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 911 | skvm::Color c; |
| 912 | c.r = c.g = c.b = c.a = p->splat(0.0f); |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 913 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 914 | skvm::F32 sy = local.y - 1.5f; |
| 915 | for (int j = 0; j < 4; j++, sy += 1.0f) { |
| 916 | skvm::F32 sx = local.x - 1.5f; |
| 917 | for (int i = 0; i < 4; i++, sx += 1.0f) { |
| 918 | skvm::Color s = sample_texel(u, sx,sy); |
| 919 | skvm::F32 w = wx[i] * wy[j]; |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 920 | |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 921 | c.r += s.r * w; |
| 922 | c.g += s.g * w; |
| 923 | c.b += s.b * w; |
| 924 | c.a += s.a * w; |
| 925 | } |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 926 | } |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 927 | return c; |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 928 | } else if (sampling.filter == SkFilterMode::kLinear) { |
Mike Reed | 3d58d5a | 2020-11-23 13:32:36 -0500 | [diff] [blame] | 929 | // Our four sample points are the corners of a logical 1x1 pixel |
| 930 | // box surrounding (x,y) at (0.5,0.5) off-center. |
| 931 | skvm::F32 left = local.x - 0.5f, |
| 932 | top = local.y - 0.5f, |
| 933 | right = local.x + 0.5f, |
| 934 | bottom = local.y + 0.5f; |
| 935 | |
| 936 | // The fractional parts of right and bottom are our lerp factors in x and y respectively. |
| 937 | skvm::F32 fx = fract(right ), |
| 938 | fy = fract(bottom); |
| 939 | |
| 940 | return lerp(lerp(sample_texel(u, left,top ), sample_texel(u, right,top ), fx), |
| 941 | lerp(sample_texel(u, left,bottom), sample_texel(u, right,bottom), fx), fy); |
| 942 | } else { |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 943 | SkASSERT(sampling.filter == SkFilterMode::kNearest); |
Mike Reed | 3d58d5a | 2020-11-23 13:32:36 -0500 | [diff] [blame] | 944 | return sample_texel(u, local.x,local.y); |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 945 | } |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 946 | }; |
| 947 | |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 948 | skvm::Color c = sample_level(upper, upperInv, upperLocal); |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 949 | if (lower) { |
Mike Reed | f8a6b5b | 2020-07-10 08:36:42 -0400 | [diff] [blame] | 950 | auto lowerLocal = SkShaderBase::ApplyMatrix(p, lowerInv, origLocal, uniforms); |
| 951 | // lower * weight + upper * (1 - weight) |
| 952 | c = lerp(c, |
| 953 | sample_level(*lower, lowerInv, lowerLocal), |
| 954 | p->uniformF(uniforms->pushF(lowerWeight))); |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 955 | } |
Mike Klein | d67a5c3 | 2020-01-06 16:01:01 -0600 | [diff] [blame] | 956 | |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 957 | // If the input is opaque and we're not in decal mode, that means the output is too. |
| 958 | // Forcing *a to 1.0 here will retroactively skip any work we did to interpolate sample alphas. |
| 959 | if (input_is_opaque |
| 960 | && fTileModeX != SkTileMode::kDecal |
| 961 | && fTileModeY != SkTileMode::kDecal) { |
Mike Reed | 6352f00 | 2020-03-14 23:30:10 -0400 | [diff] [blame] | 962 | c.a = p->splat(1.0f); |
Mike Klein | 921236b | 2020-02-13 11:20:54 -0600 | [diff] [blame] | 963 | } |
| 964 | |
Mike Klein | 913a6f5 | 2020-03-23 11:06:25 -0500 | [diff] [blame] | 965 | // Alpha-only images get their color from the paint (already converted to dst color space). |
Mike Reed | 8c1ad7e | 2020-12-02 20:41:52 -0500 | [diff] [blame] | 966 | SkColorSpace* cs = upper.colorSpace(); |
| 967 | SkAlphaType at = upper.alphaType(); |
| 968 | if (SkColorTypeIsAlphaOnly(upper.colorType())) { |
Mike Klein | 913a6f5 | 2020-03-23 11:06:25 -0500 | [diff] [blame] | 969 | c.r = paint.r; |
| 970 | c.g = paint.g; |
| 971 | c.b = paint.b; |
| 972 | |
| 973 | cs = dst.colorSpace(); |
| 974 | at = kUnpremul_SkAlphaType; |
| 975 | } |
| 976 | |
Mike Klein | bb1933e | 2020-12-02 15:45:29 -0600 | [diff] [blame] | 977 | if (sampling.useCubic) { |
Mike Klein | 5c660e0 | 2020-01-08 11:36:35 -0600 | [diff] [blame] | 978 | // Bicubic filtering naturally produces out of range values on both sides of [0,1]. |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 979 | c.a = clamp01(c.a); |
Mike Klein | 3f83bfd | 2020-01-07 12:01:50 -0600 | [diff] [blame] | 980 | |
Mike Klein | 913a6f5 | 2020-03-23 11:06:25 -0500 | [diff] [blame] | 981 | skvm::F32 limit = (at == kUnpremul_SkAlphaType || fClampAsIfUnpremul) |
Mike Klein | 3f83bfd | 2020-01-07 12:01:50 -0600 | [diff] [blame] | 982 | ? p->splat(1.0f) |
Mike Reed | 6352f00 | 2020-03-14 23:30:10 -0400 | [diff] [blame] | 983 | : c.a; |
Mike Reed | f3b9a30 | 2020-04-01 13:18:02 -0400 | [diff] [blame] | 984 | c.r = clamp(c.r, 0.0f, limit); |
| 985 | c.g = clamp(c.g, 0.0f, limit); |
| 986 | c.b = clamp(c.b, 0.0f, limit); |
Mike Klein | b1ff79a | 2020-01-07 07:53:39 -0600 | [diff] [blame] | 987 | } |
Mike Klein | 4bc86d5 | 2020-01-06 18:39:42 -0600 | [diff] [blame] | 988 | |
Mike Klein | ef0fa43 | 2020-07-29 12:35:45 -0500 | [diff] [blame] | 989 | return SkColorSpaceXformSteps{cs,at, dst.colorSpace(),dst.alphaType()}.program(p, uniforms, c); |
Mike Klein | f6a715b | 2019-12-30 15:24:18 -0600 | [diff] [blame] | 990 | } |